/*

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

* Talks directly to the USB Logical Device Driver (LDD) and 

* watches any state changes

*

*/

/**

 @file

*/

#include <usb/usblogger.h>

#include "CUsbScheduler.h"

#include "cusbotgwatcher.h"

#include "CUsbOtg.h"

#endif

static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);

static _LIT_SECURITY_POLICY_S1(KNetworkControlPolicy,KUsbmanSvrSid,ECapabilityNetworkControl);

static _LIT_SECURITY_POLICY_C1(KRequestSessionPolicy,ECapabilityCommDD);

//-----------------------------------------------------------------------------

//------------------------------ Helper watchers ------------------------------ 

//-----------------------------------------------------------------------------

//--------------------- Base class for all helper watchers -------------------- 

/**

 * The CUsbOtgBaseWatcher::CUsbOtgBaseWatcher method

 *

 * Constructor

 *

 * @param	aOwner	The device that owns the state watcher

 * @param	aLdd	A reference to the USB Logical Device Driver

 */

CUsbOtgBaseWatcher::CUsbOtgBaseWatcher(RUsbOtgDriver& aLdd)

	: CActive(CActive::EPriorityStandard), iLdd(aLdd)

	{

	CActiveScheduler::Add(this);

	}

/**

 * The CUsbOtgBaseWatcher::~CUsbOtgBaseWatcher method

 *

 * Destructor

 *

 * @internalComponent

 */

CUsbOtgBaseWatcher::~CUsbOtgBaseWatcher()

	{

	Cancel();

	}

/**

 * Instructs the state watcher to start watching.

 */

void CUsbOtgBaseWatcher::Start()

	{

	Post();

	}

//---------------------------- Id-Pin watcher class --------------------------- 

/**

 * The CUsbOtgIdPinWatcher::NewL method

 *

 * Constructs a new CUsbOtgWatcher object

 *

 * @internalComponent

 * @param	aLdd	A reference to the USB Logical Device Driver

 *

 * @return	A new CUsbOtgWatcher object

 */

CUsbOtgIdPinWatcher* CUsbOtgIdPinWatcher::NewL(RUsbOtgDriver& aLdd)

	{

	CUsbOtgIdPinWatcher* self = new (ELeave) CUsbOtgIdPinWatcher(aLdd);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 * The CUsbOtgIdPinWatcher::~CUsbOtgIdPinWatcher method

 *

 * Destructor

 *

 * @internalComponent

 */

CUsbOtgIdPinWatcher::~CUsbOtgIdPinWatcher()

	{

	Cancel();

	RProperty::Delete(KUsbOtgIdPinPresentProperty);

	}

void CUsbOtgIdPinWatcher::ConstructL()

/**

 * Performs 2nd phase construction of the OTG object.

 */

	{

	TInt err = RProperty::Define(KUsbOtgIdPinPresentProperty, RProperty::EInt, KAllowAllPolicy, KNetworkControlPolicy);

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

	    {

	    User::LeaveIfError(err);

	    }

	err = RProperty::Set(KUidUsbManCategory,KUsbOtgIdPinPresentProperty,EFalse);

	if ( err != KErrNone )

	    {

	    User::LeaveIfError(err);

	    }

	}

/**

 * The CUsbOtgIdPinWatcher::CUsbOtgIdPinWatcher method

 *

 * Constructor

 *

 * @param	aLdd	A reference to the USB Logical Device Driver

 */

CUsbOtgIdPinWatcher::CUsbOtgIdPinWatcher(RUsbOtgDriver& aLdd)

	: CUsbOtgBaseWatcher(aLdd)

	{

	}

/**

 * Called when the ID-Pin status change is reported

 */

void CUsbOtgIdPinWatcher::RunL()

	{

	Post();

	}

/**

 * Automatically called when the ID-Pin watcher is cancelled.

 */

void CUsbOtgIdPinWatcher::DoCancel()

	{

	iLdd.CancelOtgIdPinNotification();

	}

/**

 * Sets state watcher in active state

 */

void CUsbOtgIdPinWatcher::Post()

	{

	iLdd.QueueOtgIdPinNotification(iOtgIdPin, iStatus);

	switch (iOtgIdPin)

		{

		case RUsbOtgDriver::EIdPinAPlug:

			if (RProperty::Set(KUidUsbManCategory,KUsbOtgIdPinPresentProperty,ETrue) != KErrNone)

				{

				}

			else

				{

				}

			break;

		case RUsbOtgDriver::EIdPinBPlug:

		case RUsbOtgDriver::EIdPinUnknown:

			if (RProperty::Set(KUidUsbManCategory,KUsbOtgIdPinPresentProperty,EFalse) != KErrNone)

				{

				}

			else

				{

				}

			break;

		default:

			break;

		}

	SetActive();

	}

//----------------------------- VBus watcher class ---------------------------- 

/**

 * The CUsbOtgVbusWatcher::NewL method

 *

 * Constructs a new CUsbOtgVbusWatcher object

 *

 * @internalComponent

 * @param	aLdd	A reference to the USB OTG Logical Device Driver

 *

 * @return	A new CUsbOtgVbusWatcher object

 */

CUsbOtgVbusWatcher* CUsbOtgVbusWatcher::NewL(RUsbOtgDriver& aLdd)

	{

	CUsbOtgVbusWatcher* self = new (ELeave) CUsbOtgVbusWatcher(aLdd);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 * The CUsbOtgVbusWatcher::~CUsbOtgVbusWatcher method

 *

 * Destructor

 *

 * @internalComponent

 */

CUsbOtgVbusWatcher::~CUsbOtgVbusWatcher()

	{

	Cancel();

	RProperty::Delete(KUsbOtgVBusPoweredProperty);

	}

void CUsbOtgVbusWatcher::ConstructL()

/**

 * Performs 2nd phase construction of the OTG object.

 */

	{

	TInt err = RProperty::Define(KUsbOtgVBusPoweredProperty, RProperty::EInt, KAllowAllPolicy, KNetworkControlPolicy);

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

	    {

	    User::LeaveIfError(err);

	    }

	err = RProperty::Set(KUidUsbManCategory,KUsbOtgVBusPoweredProperty,EFalse);

	if ( err != KErrNone )

	    {

	    User::LeaveIfError(err);

	    }

	}

/**

 * The CUsbOtgVbusWatcher::CUsbOtgVbusWatcher method

 *

 * Constructor

 *

 * @param	aLdd	A reference to the USB OTG Logical Device Driver

 */

CUsbOtgVbusWatcher::CUsbOtgVbusWatcher(RUsbOtgDriver& aLdd)

	: CUsbOtgBaseWatcher(aLdd)

	{

	}

/**

 * Called when the Vbus status is changed

 */

void CUsbOtgVbusWatcher::RunL()

	{

	Post();

	}

/**

 * Automatically called when the VBus status watcher is cancelled.

 */

void CUsbOtgVbusWatcher::DoCancel()

	{

	iLdd.CancelOtgVbusNotification();

	}

/**

 * Sets state watcher in active state

 */

void CUsbOtgVbusWatcher::Post()

	{

	iLdd.QueueOtgVbusNotification(iOtgVbus, iStatus);

	switch (iOtgVbus)

		{

		case RUsbOtgDriver::EVbusHigh:

			if (RProperty::Set(KUidUsbManCategory,KUsbOtgVBusPoweredProperty,ETrue) != KErrNone)

				{

				}

			else

				{

				}

			break;

		case RUsbOtgDriver::EVbusLow:

		case RUsbOtgDriver::EVbusUnknown:

			if (RProperty::Set(KUidUsbManCategory,KUsbOtgVBusPoweredProperty,EFalse) != KErrNone)

				{

				}

			else

				{

				}

			break;

		default:

			break;

		}

	SetActive();

	}

//-------------------------- OTG State watcher class -------------------------- 

/**

 * The CUsbOtgStateWatcher::NewL method

 *

 * Constructs a new CUsbOtgWatcher object

 *

 * @internalComponent

 * @param	aLdd	A reference to the USB Logical Device Driver

 *

 * @return	A new CUsbOtgWatcher object

 */

CUsbOtgStateWatcher* CUsbOtgStateWatcher::NewL(RUsbOtgDriver& aLdd)

	{

	CUsbOtgStateWatcher* self = new (ELeave) CUsbOtgStateWatcher(aLdd);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 * The CUsbOtgStateWatcher::~CUsbOtgStateWatcher method

 *

 * Destructor

 *

 * @internalComponent

 */

CUsbOtgStateWatcher::~CUsbOtgStateWatcher()

	{

	Cancel();

	RProperty::Delete(KUsbOtgStateProperty);

	}

void CUsbOtgStateWatcher::ConstructL()

/**

 * Performs 2nd phase construction of the OTG object.

 */

	{

	TInt err = RProperty::Define(KUsbOtgStateProperty, RProperty::EInt, KAllowAllPolicy, KNetworkControlPolicy);

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

	    {

	    User::LeaveIfError(err);

	    }

	err = RProperty::Set(KUidUsbManCategory,KUsbOtgStateProperty,RUsbOtgDriver::EStateReset);

	if ( err != KErrNone )

	    {

	    User::LeaveIfError(err);

	    }

	}

/**

 * The CUsbOtgIdPinWatcher::CUsbOtgIdPinWatcher method

 *

 * Constructor

 *

 * @param	aLdd	A reference to the USB Logical Device Driver

 */

CUsbOtgStateWatcher::CUsbOtgStateWatcher(RUsbOtgDriver& aLdd)

	: CUsbOtgBaseWatcher(aLdd)

	{

	iOtgState = RUsbOtgDriver::EStateReset;

	}

/**

 * Called when the OTG State change is reported

 */

void CUsbOtgStateWatcher::RunL()

	{

	Post();

	}

/**

 * Automatically called when the OTG State watcher is cancelled.

 */

void CUsbOtgStateWatcher::DoCancel()

	{

	iLdd.CancelOtgStateNotification();

	}

/**

 * Sets state watcher in active state

 */

void CUsbOtgStateWatcher::Post()

	{

	iLdd.QueueOtgStateNotification(iOtgState, iStatus);

	if (RProperty::Set(KUidUsbManCategory,KUsbOtgStateProperty,(TInt)iOtgState) != KErrNone)

	{

	}

	SetActive();

	}

//-------------------------- OTG Events watcher class ------------------------- 

/**

 * The CUsbOtgEventWatcher::NewL method

 *

 * Constructs a new CUsbOtgEventWatcher object

 *

 * @internalComponent

 * @param	aOwner		The CUsbOtg that owns the state watcher

 * @param	aLdd		A reference to the USB Logical Device Driver

 * @param	aOtgEvent	A reference to the OTG Event

 *

 * @return	A new CUsbOtgEventWatcher object

 */

CUsbOtgEventWatcher* CUsbOtgEventWatcher::NewL(CUsbOtg& aOwner, RUsbOtgDriver& aLdd,

											   RUsbOtgDriver::TOtgEvent& aOtgEvent)

	{

	CUsbOtgEventWatcher* self = new (ELeave) CUsbOtgEventWatcher(aOwner, aLdd, aOtgEvent);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 * The CUsbOtgEventWatcher::~CUsbOtgEventWatcher method

 *

 * Destructor

 *

 * @internalComponent

 */

CUsbOtgEventWatcher::~CUsbOtgEventWatcher()

	{

	Cancel();

	}

void CUsbOtgEventWatcher::ConstructL()

/**

 * Performs 2nd phase construction of the OTG object.

 */

	{

	}

/**

 * The CUsbOtgEventWatcher::CUsbOtgEventWatcher method

 *

 * Constructor

 *

 * @param	aOwner		A reference to the CUsbOtg object that owns the state watcher

 * @param	aLdd		A reference to the USB Logical Device Driver

 * @param	aOtgEvent	A reference to the OTG Event

 */

CUsbOtgEventWatcher::CUsbOtgEventWatcher(CUsbOtg& aOwner, RUsbOtgDriver& aLdd,