/*

* 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 the main object of Usbman that manages all the USB Classes

* and the USB Logical Device (via CUsbDeviceStateWatcher).

*

*/

/**

 @file

*/

#include <cusbclasscontrolleriterator.h>

#include <cusbclasscontrollerbase.h>

#include <cusbclasscontrollerplugin.h>

#include <bafl/sysutil.h>

#include <usb/usblogger.h>

#include <e32svr.h>

#include <e32base.h>

#include <e32std.h>

#include <f32file.h>

#include <barsc.h>

#include <barsread.h>

#include <bautils.h>

#include <e32property.h> //Publish & Subscribe header

#ifdef USE_DUMMY_CLASS_CONTROLLER

#include "CUsbDummyClassController.h"

#endif

#include "MUsbDeviceNotify.h"

#include "UsbSettings.h"

#include "CUsbServer.h"

#include "UsbUtils.h"

#include "CUsbDevice.h"

#include "CUsbDeviceStateWatcher.h"

#include "CPersonality.h"

#include "usbmancenrepmanager.h"

#include "usbmanprivatecrkeys.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CUsbDeviceTraces.h"

#endif

_LIT(KUsbLDDName, "eusbc"); //Name used in call to User::LoadLogicalDevice

_LIT(KUsbLDDFreeName, "Usbc"); //Name used in call to User::FreeLogicalDevice

// Panic category only used in debug builds

#ifdef _DEBUG

_LIT(KUsbDevicePanicCategory, "UsbDevice");

#endif

/**

 * Panic codes for the USB Device Class

 */

enum TUsbDevicePanic

	{

	/** Class called while in an illegal state */

	EBadAsynchronousCall = 0,

	EConfigurationError,

	EResourceFileNotFound,

	/** ConvertUidsL called with an array that is not empty */

	EUidArrayNotEmpty,

	};

CUsbDevice* CUsbDevice::NewL(CUsbServer& aUsbServer)

/**

 * Constructs a CUsbDevice object.

 *

 * @return	A new CUsbDevice object

 */

	{

    OstTraceFunctionEntry0( CUSBDEVICE_NEWL_ENTRY );

	CUsbDevice* r = new (ELeave) CUsbDevice(aUsbServer);

	CleanupStack::PushL(r);

	r->ConstructL();

	CleanupStack::Pop(r);

	OstTraceFunctionExit0( CUSBDEVICE_NEWL_EXIT );

	return r;

	}

CUsbDevice::~CUsbDevice()

/**

 * Destructor.

 */

	{

    OstTraceFunctionEntry0( CUSBDEVICE_CUSBDEVICE_DES_ENTRY );

	// Cancel any outstanding asynchronous operation.

	Cancel();

	delete iUsbClassControllerIterator;

	iSupportedClasses.ResetAndDestroy();

	iSupportedPersonalities.ResetAndDestroy();

	iSupportedClassUids.Close();

	iExtensionPlugins.ResetAndDestroy();

	delete iCenRepManager;

	delete  iDeviceConfiguration.iManufacturerName;

	delete  iDeviceConfiguration.iProductName;  

	if(iEcom)

		iEcom->Close();

	REComSession::FinalClose();

	// Free any memory allocated to the list of observers. Note that

	// we don't want to call ResetAndDestroy, because we don't own

	// the observers themselves.

	iObservers.Reset();

#ifndef __OVER_DUMMYUSBDI__

#ifndef __WINS__

	OstTrace1( TRACE_NORMAL, CUSBDEVICE_CUSBDEVICE, "CUsbDevice::~CUsbDevice;about to delete device state watcher @ %08x", (TUint32)iDeviceStateWatcher );

	delete iDeviceStateWatcher;

	OstTrace0( TRACE_NORMAL, CUSBDEVICE_CUSBDEVICE_DUP1, "CUsbDevice::~CUsbDevice;deleted device state watcher" );

	iLdd.Close();

	OstTrace0( TRACE_NORMAL, CUSBDEVICE_CUSBDEVICE_DUP2, "CUsbDevice::~CUsbDevice;Freeing logical device" );

	TInt err = User::FreeLogicalDevice(KUsbLDDFreeName);

	//Putting the LOGTEXT2 inside the if statement prevents a compiler

	//warning about err being unused in UREL builds.

	if(err)

		{

        OstTrace1( TRACE_NORMAL, CUSBDEVICE_CUSBDEVICE_DUP3, "CUsbDevice::~CUsbDevice; User::FreeLogicalDevice returned err=%d", err );

		}

#endif

#endif	

	delete iDefaultSerialNumber;

	OstTraceFunctionExit0( CUSBDEVICE_CUSBDEVICE_DES_EXIT );

	}

CUsbDevice::CUsbDevice(CUsbServer& aUsbServer)

	: CActive(EPriorityStandard)

	, iDeviceState(EUsbDeviceStateUndefined)

	, iServiceState(EUsbServiceIdle)

	, iUsbServer(aUsbServer)

	, iPersonalityCfged(EFalse)

/**

 * Constructor.

 */

	{

	CActiveScheduler::Add(this);

	}

void CUsbDevice::ConstructL()

/**

 * Performs 2nd phase construction of the USB device.

 */

	{

	OstTraceFunctionEntry0( CUSBDEVICE_CONSTRUCTL_ENTRY );

	iEcom = &(REComSession::OpenL());

	iUsbClassControllerIterator = new(ELeave) CUsbClassControllerIterator(iSupportedClasses);

	iCenRepManager = CUsbManCenRepManager::NewL(*this);

	iDeviceConfiguration.iManufacturerName   = HBufC::NewL(KUsbStringDescStringMaxSize);

	iDeviceConfiguration.iProductName        = HBufC::NewL(KUsbStringDescStringMaxSize);

#ifndef __OVER_DUMMYUSBDI__	

#ifndef __WINS__

	OstTrace0( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL, "CUsbDevice::ConstructL; About to load LDD" );

	TInt err = User::LoadLogicalDevice(KUsbLDDName);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

        OstTrace1( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP10, "CUsbDevice::ConstructL;err=%d", err );

		User::Leave(err);

		}

	OstTrace0( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP1, "CUsbDevice::ConstructL; About to open LDD" );	

	err = iLdd.Open(0);

	if(err < 0)

	    {

        OstTrace1( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP9, "CUsbDevice::ConstructL;iLdd.Open(0) with error=%d", err );

        User::Leave(err);

	    }

	OstTrace0( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP2, "CUsbDevice::ConstructL; LDD opened" );

	// hide bus from host while interfaces are being set up

	iLdd.DeviceDisconnectFromHost();

	// Does the USC support cable detection while powered off? If no, then 

	// call PowerUpUdc when RUsb::Start finishes, as is obvious. If yes, we 

	// delay calling PowerUpUdc until both the service state is 'started' and 

	// the device state is not undefined. This is to save power in the UDC 

	// when there's no point it being powered.

	TUsbDeviceCaps devCapsBuf;

	err = iLdd.DeviceCaps(devCapsBuf);

	if(err < 0)

	    {

        OstTrace1( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP11, "CUsbDevice::ConstructL;iLdd.DeviceCaps(devCapsBuf) with error=%d", err );

        User::Leave(err);

	    }

	if ( devCapsBuf().iFeatureWord1 & KUsbDevCapsFeatureWord1_CableDetectWithoutPower )

		{

        OstTrace0( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP3, "CUsbDevice::ConstructL: UDC supports cable detect when unpowered" );

		iUdcSupportsCableDetectWhenUnpowered = ETrue;

		}

	else

		{

        OstTrace0( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP4, "CUsbDevice::ConstructL; UDC does not support cable detect when unpowered" );

		}

	TUsbcDeviceState deviceState;

	err = iLdd.DeviceStatus(deviceState);

	if(err < 0)

	    {

        OstTrace1( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP13, "CUsbDevice::ConstructL;iLdd.DeviceStatus(deviceState) with error=%d", err );

        User::Leave(err);

	    }

	SetDeviceState(deviceState);

	OstTrace0( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP5, "CUsbDevice::ConstructL; Got device state" );

	iDeviceStateWatcher = CUsbDeviceStateWatcher::NewL(*this, iLdd);

	iDeviceStateWatcher->Start();

	// Get hold of the default serial number in the driver

	// This is so it can be put back in place when a device that sets a

	// different serial number (through the P&S key) is stopped

	iDefaultSerialNumber = HBufC16::NewL(KUsbStringDescStringMaxSize);

	TPtr16 serNum = iDefaultSerialNumber->Des();

	err = iLdd.GetSerialNumberStringDescriptor(serNum);

	if (err == KErrNotFound)

		{

		delete iDefaultSerialNumber;

		iDefaultSerialNumber = NULL;

		OstTrace0( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP6, "CUsbDevice::ConstructL; No default serial number" );

		}

	else

		{

        if(err < 0)

            {

            OstTrace1( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP12, "CUsbDevice::ConstructL;error=%d", err );

            User::Leave(err);

            }

#ifdef _DEBUG

		OstTraceExt1( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP7, "CUsbDevice::ConstructL;serNum=%S", serNum );

#endif //_DEBUG  

		}

	OstTrace0( TRACE_NORMAL, CUSBDEVICE_CONSTRUCTL_DUP8, "CUsbDevice::ConstructL; UsbDevice::ConstructL() finished" );

#endif

#endif

#ifndef __OVER_DUMMYUSBDI__

	InstantiateExtensionPluginsL();

#endif

	OstTraceFunctionExit0( CUSBDEVICE_CONSTRUCTL_EXIT );

	}

void CUsbDevice::InstantiateExtensionPluginsL()

	{

    OstTraceFunctionEntry0( CUSBDEVICE_INSTANTIATEEXTENSIONPLUGINSL_ENTRY );

	const TUid KUidExtensionPluginInterface = TUid::Uid(KUsbmanExtensionPluginInterfaceUid);

	RImplInfoPtrArray implementations;

	const TEComResolverParams noResolverParams;

	REComSession::ListImplementationsL(KUidExtensionPluginInterface, noResolverParams, KRomOnlyResolverUid, implementations);

	CleanupResetAndDestroyPushL(implementations);

	OstTrace1( TRACE_FLOW, CUSBDEVICE_INSTANTIATEEXTENSIONPLUGINSL, "CUsbDevice::InstantiateExtensionPluginsL;Number of implementations of extension plugin interface: %d", implementations.Count() );

	for (TInt i=0; i<implementations.Count(); i++)

		{

		CUsbmanExtensionPlugin* plugin = CUsbmanExtensionPlugin::NewL(implementations[i]->ImplementationUid(), *this);

		CleanupStack::PushL(plugin);

		iExtensionPlugins.AppendL(plugin); // transfer ownership to iExtensionPlugins

		CleanupStack::Pop(plugin);

		OstTrace1( TRACE_NORMAL, CUSBDEVICE_INSTANTIATEEXTENSIONPLUGINSL_DUP1, 

		        "CUsbDevice::InstantiateExtensionPluginsL;Added extension plugin with UID 0x%08x", 

		        implementations[i]->ImplementationUid().iUid );

		}

	CleanupStack::PopAndDestroy(&implementations);

	OstTraceFunctionExit0( CUSBDEVICE_INSTANTIATEEXTENSIONPLUGINSL_EXIT );

	}

void CUsbDevice::EnumerateClassControllersL()

/**

 * Loads all USB class controllers at startup.

 *

 */

	{

	OstTraceFunctionEntry0( CUSBDEVICE_ENUMERATECLASSCONTROLLERSL_ENTRY );

#ifdef USE_DUMMY_CLASS_CONTROLLER

	//create a TLinearOrder to supply the comparison function, Compare(), to be used  

	//to determine the order to add class controllers

	TLinearOrder<CUsbClassControllerBase> order(CUsbClassControllerBase::Compare);

	// For GT171 automated tests, create three instances of the dummy class 

	// controller, which will read their behaviour from an ini file. Do not 

	// make any other class controllers.

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

		{

		AddClassControllerL(CUsbDummyClassController::NewL(*this, ii), order);	

		}

	TInt err = iUsbClassControllerIterator->First();   

	if(err < 0)

	    {

        OstTrace1( TRACE_NORMAL, CUSBDEVICE_ENUMERATECLASSCONTROLLERSL_DUP2, "CUsbDevice::EnumerateClassControllersL;iUsbClassControllerIterator->First() with error=%d", err );

        User::Leave(err);

	    }

#else

	// Add a class controller statically.

	// The next line shows how to add a class controller, CUsbExampleClassController,

	// statically

	// AddClassControllerL(CUsbExampleClassController::NewL(*this),order);

	// Load class controller plug-ins

	RImplInfoPtrArray implementations;

	const TEComResolverParams noResolverParams;

	REComSession::ListImplementationsL(KUidUsbPlugIns, noResolverParams, KRomOnlyResolverUid, implementations);

  	CleanupResetAndDestroyPushL(implementations);

	OstTrace1( TRACE_NORMAL, CUSBDEVICE_ENUMERATECLASSCONTROLLERSL, "CUsbDevice::EnumerateClassControllersL;Number of implementations to load %d", implementations.Count() );

	for (TInt i=0; i<implementations.Count(); i++)

		{

        OstTrace1( TRACE_NORMAL, CUSBDEVICE_ENUMERATECLASSCONTROLLERSL_DUP1, "CUsbDevice::EnumerateClassControllersL;Adding class controller with UID %x", implementations[i]->ImplementationUid().iUid );

        const TUid uid = implementations[i]->ImplementationUid();

		TInt err = iSupportedClassUids.Append(uid);

		if(err < 0)

		    {

            OstTrace1( TRACE_NORMAL, CUSBDEVICE_ENUMERATECLASSCONTROLLERSL_DUP3, "CUsbDevice::EnumerateClassControllersL;iSupportedClassUids.Append(uid) with error=%d", err );

            User::Leave(err);

		    }

		}	

	CleanupStack::PopAndDestroy(&implementations);

#endif // USE_DUMMY_CLASS_CONTROLLER

	OstTraceFunctionExit0( CUSBDEVICE_ENUMERATECLASSCONTROLLERSL_EXIT );

	}

void CUsbDevice::AddClassControllerL(CUsbClassControllerBase* aClassController, 

									TLinearOrder<CUsbClassControllerBase> aOrder)

/**

 * Adds a USB class controller to the device. The controller will now be

 * managed by this device. Note that the class controller, aClassController, is now

 * owned by this function and can be destroyed by it.  Calling functions do not need to 

 * destroy the class controller. 

 *

 * @param	aClassController	Class to be managed

 * @param   aOrder              Specifies order CUsbClassControllerBase objects are to be

 *                              added

 */

	{

	OstTraceFunctionEntry0( CUSBDEVICE_ADDCLASSCONTROLLERL_ENTRY );

	TInt rc = KErrNone;	

	if(isPersonalityCfged()) // do not take into account priorities

		{

		rc = iSupportedClasses.Append(aClassController);	

		}

	else

		{

		rc = iSupportedClasses.InsertInOrderAllowRepeats(

		aClassController, aOrder);

		} 

	if (rc != KErrNone) 

		{

		// Avoid memory leak by deleting class controller if the append fails.

		delete aClassController;

		OstTrace1( TRACE_NORMAL, CUSBDEVICE_ADDCLASSCONTROLLERL, "CUsbDevice::AddClassControllerL;Leave rc=%d", rc );

		User::Leave(rc);

		}

	OstTraceFunctionExit0( CUSBDEVICE_ADDCLASSCONTROLLERL_EXIT );

	}

void CUsbDevice::RegisterObserverL(MUsbDeviceNotify& aObserver)

/**

 * Register an observer of the device.

 * Presently, the device supports watching state.

 *

 * @param	aObserver	New Observer of the device

 */

	{

	OstTraceFunctionEntry0( CUSBDEVICE_REGISTEROBSERVERL_ENTRY );

	TInt err = iObservers.Append(&aObserver);

	if(err < 0)

	    {

        OstTrace1( TRACE_NORMAL, CUSBDEVICE_REGISTEROBSERVERL, "CUsbDevice::RegisterObserverL;iObservers.Append(&aObserver) with err=%d", err );

        User::Leave(err);

	    }

	OstTraceFunctionExit0( CUSBDEVICE_REGISTEROBSERVERL_EXIT );

	}

void CUsbDevice::DeRegisterObserver(MUsbDeviceNotify& aObserver)

/**

 * De-registers an existing device observer.

 *

 * @param	aObserver	The existing device observer to be de-registered

 */

	{

	OstTraceFunctionEntry0( CUSBDEVICE_DEREGISTEROBSERVER_ENTRY );

	TInt index = iObservers.Find(&aObserver);

	if (index >= 0)

		iObservers.Remove(index);

	OstTraceFunctionExit0( CUSBDEVICE_DEREGISTEROBSERVER_EXIT );

	}

void CUsbDevice::StartL()

/**

 * Start the USB Device and all its associated USB classes.

 * Reports errors and state changes via observer interface.

 */

	{

	OstTraceFunctionEntry0( CUSBDEVICE_STARTL_ENTRY );

	Cancel();

	SetServiceState(EUsbServiceStarting);

	TRAPD(err, SetDeviceDescriptorL());

	if ( err != KErrNone )

		{

		SetServiceState(EUsbServiceIdle);	

		OstTrace1( TRACE_NORMAL, CUSBDEVICE_STARTL, "CUsbDevice::StartL;Leave with error=%d", err );

		User::Leave(err);		

		}

	iLastError = KErrNone;

	StartCurrentClassController();

	OstTraceFunctionExit0( CUSBDEVICE_STARTL_EXIT );

	}

void CUsbDevice::Stop()

/**

 * Stop the USB device and all its associated USB classes.

 */

	{

	OstTraceFunctionEntry0( CUSBDEVICE_STOP_ENTRY );

	Cancel();

	SetServiceState(EUsbServiceStopping);

	iLastError = KErrNone;

	StopCurrentClassController();

	OstTraceFunctionExit0( CUSBDEVICE_STOP_EXIT );

	}

void CUsbDevice::SetServiceState(TUsbServiceState aState)

/**

 * Change the device's state and report the change to the observers.

 *

 * @param	aState	New state that the device is moving to

 */

	{

    OstTraceFunctionEntry0( CUSBDEVICE_SETSERVICESTATE_ENTRY );

	OstTraceExt2( TRACE_NORMAL, CUSBDEVICE_SETSERVICESTATE, 

	        "CUsbDevice::SetServiceState;iServiceState=%d;aState=%d", iServiceState, aState );

	if (iServiceState != aState)

		{

		// Change state straight away in case any of the clients check it

		TUsbServiceState oldState = iServiceState;