/*

* Copyright (c) 2008-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 "cusbhost.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cusbhostTraces.h"

#endif

CUsbHost* CUsbHost::iInstance = 0;

	{

	if(iInstance == 0)

		{

		CleanupStack::PushL(iInstance);		

		iInstance->ConstructL();		

		CleanupStack::Pop(iInstance);

		}	

	return iInstance;

	}

CUsbHost::~CUsbHost()

	{

    OstTraceFunctionEntry0( CUSBHOST_CUSBHOST_DES_ENTRY );

	Stop();

	TInt i =0;

	for(i=0;i<ENumMonitor;i++)

		{

		delete iUsbHostWatcher[i];

		iUsbHostWatcher[i] = NULL;

		}

	iObservers.Close();

	iInstance = 0;

	OstTraceFunctionExit0( CUSBHOST_CUSBHOST_DES_EXIT );

	}

	{

    OstTraceFunctionEntry0( CUSBHOST_CUSBHOST_CONS_ENTRY );

	OstTraceFunctionExit0( CUSBHOST_CUSBHOST_CONS_EXIT );

	}

void CUsbHost::ConstructL()

	{

    OstTraceFunctionEntry0( CUSBHOST_CONSTRUCTL_ENTRY );

	iUsbHostWatcher[EHostEventMonitor] = 

			CActiveUsbHostEventWatcher::NewL(iUsbHostStack,*this,iHostEventInfo);

	iUsbHostWatcher[EHostMessageMonitor] = 

			CActiveUsbHostMessageWatcher::NewL(iUsbHostStack,*this,iHostMessage);

	OstTraceFunctionExit0( CUSBHOST_CONSTRUCTL_EXIT );

	}

void CUsbHost::StartL()

	{

	OstTraceFunctionEntry0( CUSBHOST_STARTL_ENTRY );

	if(!iHasBeenStarted)

		{

		TInt err = iUsbHostStack.Connect();

		if(err < 0)

		    {

            OstTrace1( TRACE_NORMAL, CUSBHOST_STARTL, "CUsbHost::StartL; iUsbHostStack.Connect() error. Leave error=%d", err );

            User::Leave(err);

		    }

		for(TInt i=0;i<ENumMonitor;i++)

			{

			iUsbHostWatcher[i]->Post();

			}

		iHasBeenStarted = ETrue;

		}

	OstTraceFunctionExit0( CUSBHOST_STARTL_EXIT );

	}

void CUsbHost::Stop()

	{

	OstTraceFunctionEntry0( CUSBHOST_STOP_ENTRY );

	TInt i=0;

	for(i=0;i<ENumMonitor;i++)

		{

		if (iUsbHostWatcher[i])

			{

			iUsbHostWatcher[i]->Cancel();

			}

		}

	iUsbHostStack.Close();

	iHasBeenStarted = EFalse;

	OstTraceFunctionExit0( CUSBHOST_STOP_EXIT );

	}

void CUsbHost::RegisterObserverL(MUsbOtgHostNotifyObserver& aObserver)

	{

	OstTraceFunctionEntry0( CUSBHOST_REGISTEROBSERVERL_ENTRY );

	iObservers.AppendL(&aObserver);

	UpdateNumOfObservers();

	OstTraceFunctionExit0( CUSBHOST_REGISTEROBSERVERL_EXIT );

	}

void CUsbHost::DeregisterObserver(MUsbOtgHostNotifyObserver& aObserver)

	{

	OstTraceFunctionEntry0( CUSBHOST_DEREGISTEROBSERVER_ENTRY );

	TInt index = iObservers.Find(&aObserver);

	if(index == KErrNotFound)

		{

        OstTrace0( TRACE_NORMAL, CUSBHOST_DEREGISTEROBSERVER, "CUsbHost::DeregisterObserver;  Cannot remove observer, not found" );

		}

	else

		{

		iObservers.Remove(index);

		}

	UpdateNumOfObservers();

	OstTraceFunctionExit0( CUSBHOST_DEREGISTEROBSERVER_EXIT );

	}

TInt CUsbHost::GetSupportedLanguages(TUint aDeviceId,RArray<TUint>& aLangIds)

	{

	OstTraceFunctionEntry0( CUSBHOST_GETSUPPORTEDLANGUAGES_ENTRY );

	TInt err = KErrNone;

	if ( iUsbHostStack.Handle() )

		{

		err = iUsbHostStack.GetSupportedLanguages(aDeviceId,aLangIds);

		}

	else

		{

		err = KErrBadHandle;

		}

	OstTraceFunctionExit0( CUSBHOST_GETSUPPORTEDLANGUAGES_EXIT );

	return err;

	}

TInt CUsbHost::GetManufacturerStringDescriptor(TUint aDeviceId,TUint aLangId,TName& aString)

	{

	OstTraceFunctionEntry0( CUSBHOST_GETMANUFACTURERSTRINGDESCRIPTOR_ENTRY );

	TInt err = KErrNone;

	if ( iUsbHostStack.Handle() )

		{

		err = iUsbHostStack.GetManufacturerStringDescriptor(aDeviceId,aLangId,aString);

		}

	else

		{

		err = KErrBadHandle;

		}

	OstTraceFunctionExit0( CUSBHOST_GETMANUFACTURERSTRINGDESCRIPTOR_EXIT );

	return err;

	}

TInt CUsbHost::GetProductStringDescriptor(TUint aDeviceId,TUint aLangId,TName& aString)

	{

	OstTraceFunctionEntry0( CUSBHOST_GETPRODUCTSTRINGDESCRIPTOR_ENTRY );

	TInt err = KErrNone;

	if ( iUsbHostStack.Handle() )

		{

		err = iUsbHostStack.GetProductStringDescriptor(aDeviceId,aLangId,aString);

		}

	else

		{

		err = KErrBadHandle;

		}

	OstTraceFunctionExit0( CUSBHOST_GETPRODUCTSTRINGDESCRIPTOR_EXIT );

	return err;

	}

TInt CUsbHost::GetOtgDescriptor(TUint aDeviceId, TOtgDescriptor& otgDescriptor)

	{

	OstTraceFunctionEntry0( CUSBHOST_GETOTGDESCRIPTOR_ENTRY );

	TInt err(KErrNone);

	if (iUsbHostStack.Handle())

		{

		err = iUsbHostStack.GetOtgDescriptor(aDeviceId, otgDescriptor);

		}

	else

		{

		err = KErrBadHandle;

		}

	OstTraceFunctionExit0( CUSBHOST_GETOTGDESCRIPTOR_EXIT );

	return err;

	}

void CUsbHost::NotifyHostEvent(TUint aWatcherId)

	{

    OstTraceFunctionEntry0( CUSBHOST_NOTIFYHOSTEVENT_ENTRY );

	if(aWatcherId == EHostEventMonitor)

		{

		OstTrace1( TRACE_NORMAL, CUSBHOST_NOTIFYHOSTEVENT, "CUsbHost::NotifyHostEvent;DeviceId=%d", iHostEventInfo.iDeviceId );

		OstTrace1( TRACE_NORMAL, CUSBHOST_NOTIFYHOSTEVENT_DUP1, "CUsbHost::NotifyHostEvent;iEventType=%d", iHostEventInfo.iEventType );

		OstTrace1( TRACE_NORMAL, CUSBHOST_NOTIFYHOSTEVENT_DUP2, "CUsbHost::NotifyHostEvent;TDriverLoadStatus=%d", iHostEventInfo.iDriverLoadStatus );

		OstTrace1( TRACE_NORMAL, CUSBHOST_NOTIFYHOSTEVENT_DUP3, "CUsbHost::NotifyHostEvent;VID=%d", iHostEventInfo.iVid );

		OstTrace1( TRACE_NORMAL, CUSBHOST_NOTIFYHOSTEVENT_DUP4, "CUsbHost::NotifyHostEvent;Pid=%d", iHostEventInfo.iPid );

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

			{

			iObservers[i]->UsbHostEvent(iHostEventInfo);

			}

		}

	else

		{

		OstTrace1( TRACE_NORMAL, CUSBHOST_NOTIFYHOSTEVENT_DUP5, "CUsbHost::NotifyHostEvent;Host Message=%d", iHostMessage );

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

			{

			iObservers[i]->UsbOtgHostMessage(iHostMessage);

			}

		}

	OstTraceFunctionExit0( CUSBHOST_NOTIFYHOSTEVENT_EXIT );

	}

void CUsbHost::UpdateNumOfObservers()

	{

	OstTraceFunctionEntry0( CUSBHOST_UPDATENUMOFOBSERVERS_ENTRY );

	iNumOfObservers = iObservers.Count();

	OstTraceFunctionExit0( CUSBHOST_UPDATENUMOFOBSERVERS_EXIT );

	}

TInt CUsbHost::EnableDriverLoading()

	{

	OstTraceFunctionEntry0( CUSBHOST_ENABLEDRIVERLOADING_ENTRY );

	TInt err = KErrNone;

	if ( iUsbHostStack.Handle() )

		{

		err = iUsbHostStack.EnableDriverLoading();

		}

	else

		{

		err = KErrBadHandle;

		}

	OstTraceFunctionExit0( CUSBHOST_ENABLEDRIVERLOADING_EXIT );

	return err;

	}

void CUsbHost::DisableDriverLoading()

	{

	OstTraceFunctionEntry0( CUSBHOST_DISABLEDRIVERLOADING_ENTRY );

	if ( iUsbHostStack.Handle() )

		{

		iUsbHostStack.DisableDriverLoading();

		}

	OstTraceFunctionExit0( CUSBHOST_DISABLEDRIVERLOADING_EXIT );

	}