/*
* Copyright (c) 2008-2009 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:
* 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"
#include <usb/usbshared.h>
#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, "USBSVR-OTGWATCHER");
#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)
{
LOG_FUNC
CActiveScheduler::Add(this);
}
/**
* The CUsbOtgBaseWatcher::~CUsbOtgBaseWatcher method
*
* Destructor
*
* @internalComponent
*/
CUsbOtgBaseWatcher::~CUsbOtgBaseWatcher()
{
LOG_FUNC
Cancel();
}
/**
* Instructs the state watcher to start watching.
*/
void CUsbOtgBaseWatcher::Start()
{
LOG_FUNC
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)
{
LOG_STATIC_FUNC_ENTRY
CUsbOtgIdPinWatcher* self = new (ELeave) CUsbOtgIdPinWatcher(aLdd);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
/**
* The CUsbOtgIdPinWatcher::~CUsbOtgIdPinWatcher method
*
* Destructor
*
* @internalComponent
*/
CUsbOtgIdPinWatcher::~CUsbOtgIdPinWatcher()
{
LOG_FUNC
Cancel();
RProperty::Delete(KUsbOtgIdPinPresentProperty);
}
void CUsbOtgIdPinWatcher::ConstructL()
/**
* Performs 2nd phase construction of the OTG object.
*/
{
LOG_FUNC
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)
{
LOG_FUNC
}
/**
* Called when the ID-Pin status change is reported
*/
void CUsbOtgIdPinWatcher::RunL()
{
LOG_FUNC
LOGTEXT2(_L8(">>CUsbOtgIdPinWatcher::RunL [iStatus=%d]"), iStatus.Int());
LEAVEIFERRORL(iStatus.Int());
Post();
LOGTEXT(_L8("<<CUsbOtgIdPinWatcher::RunL"));
}
/**
* Automatically called when the ID-Pin watcher is cancelled.
*/
void CUsbOtgIdPinWatcher::DoCancel()
{
LOG_FUNC
iLdd.CancelOtgIdPinNotification();
}
/**
* Sets state watcher in active state
*/
void CUsbOtgIdPinWatcher::Post()
{
LOG_FUNC
LOGTEXT(_L8("CUsbOtgIdPinWatcher::Post() - About to call QueueOtgIdPinNotification"));
iLdd.QueueOtgIdPinNotification(iOtgIdPin, iStatus);
switch (iOtgIdPin)
{
case RUsbOtgDriver::EIdPinAPlug:
if (RProperty::Set(KUidUsbManCategory,KUsbOtgIdPinPresentProperty,ETrue) != KErrNone)
{
LOGTEXT2(_L8(">>CUsbOtgIdPinWatcher::Post [iOtgIdPin=%d] - failed to set the property value"), iOtgIdPin);
}
else
{
LOGTEXT2(_L8(">>CUsbOtgIdPinWatcher::Post [iOtgIdPin=%d] - property is set to 1"), iOtgIdPin);
}
break;
case RUsbOtgDriver::EIdPinBPlug:
case RUsbOtgDriver::EIdPinUnknown:
if (RProperty::Set(KUidUsbManCategory,KUsbOtgIdPinPresentProperty,EFalse) != KErrNone)
{
LOGTEXT2(_L8(">>CUsbOtgIdPinWatcher::Post [iOtgIdPin=%d] - failed to set the property value"), iOtgIdPin);
}
else
{
LOGTEXT2(_L8(">>CUsbOtgIdPinWatcher::Post [iOtgIdPin=%d] - property is set to 0"), iOtgIdPin);
}
break;
default:
LOGTEXT2(_L8(">>CUsbOtgIdPinWatcher::Post [iOtgIdPin=%d] is unrecognized, re-request QueueOtgIdPinNotification"), iOtgIdPin);
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)
{
LOG_STATIC_FUNC_ENTRY
CUsbOtgVbusWatcher* self = new (ELeave) CUsbOtgVbusWatcher(aLdd);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
/**
* The CUsbOtgVbusWatcher::~CUsbOtgVbusWatcher method
*
* Destructor
*
* @internalComponent
*/
CUsbOtgVbusWatcher::~CUsbOtgVbusWatcher()
{
LOG_FUNC
Cancel();
RProperty::Delete(KUsbOtgVBusPoweredProperty);
}
void CUsbOtgVbusWatcher::ConstructL()
/**
* Performs 2nd phase construction of the OTG object.
*/
{
LOG_FUNC
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)
{
LOG_FUNC
}
/**
* Called when the Vbus status is changed
*/
void CUsbOtgVbusWatcher::RunL()
{
LOG_FUNC
LOGTEXT2(_L8(">>CUsbOtgVbusWatcher::RunL [iStatus=%d]"), iStatus.Int());
LEAVEIFERRORL(iStatus.Int());
Post();
LOGTEXT(_L8("<<CUsbOtgVbusWatcher::RunL"));
}
/**
* Automatically called when the VBus status watcher is cancelled.
*/
void CUsbOtgVbusWatcher::DoCancel()
{
LOG_FUNC
iLdd.CancelOtgVbusNotification();
}
/**
* Sets state watcher in active state
*/
void CUsbOtgVbusWatcher::Post()
{
LOG_FUNC
LOGTEXT(_L8("CUsbOtgVbusWatcher::Post() - About to call QueueOtgVbusNotification"));
iLdd.QueueOtgVbusNotification(iOtgVbus, iStatus);
switch (iOtgVbus)
{
case RUsbOtgDriver::EVbusHigh:
if (RProperty::Set(KUidUsbManCategory,KUsbOtgVBusPoweredProperty,ETrue) != KErrNone)
{
LOGTEXT2(_L8(">>CUsbOtgVbusWatcher::Post [iOtgVbus=%d](EVbusHigh) - failed to set the property value"), iOtgVbus);
}
else
{
LOGTEXT2(_L8(">>CUsbOtgVbusWatcher::Post [iOtgVbus=%d](EVbusHigh) - property is set to ETrue"), iOtgVbus);
}
break;
case RUsbOtgDriver::EVbusLow:
case RUsbOtgDriver::EVbusUnknown:
if (RProperty::Set(KUidUsbManCategory,KUsbOtgVBusPoweredProperty,EFalse) != KErrNone)
{
LOGTEXT2(_L8(">>CUsbOtgVbusWatcher::Post [iOtgVbus=%d](1 - EVbusLow, 2 - EVbusUnknown) - failed to set the property value"), iOtgVbus);
}
else
{
LOGTEXT2(_L8(">>CUsbOtgVbusWatcher::Post [iOtgVbus=%d](1 - EVbusLow, 2 - EVbusUnknown) - property is set to EFalse"), iOtgVbus);
}
break;
default:
LOGTEXT2(_L8(">>CUsbOtgVbusWatcher::RunL [iOtgVbus=%d] is unrecognized, re-request QueueOtgVbusNotification"), iOtgVbus);
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)
{
LOG_STATIC_FUNC_ENTRY
CUsbOtgStateWatcher* self = new (ELeave) CUsbOtgStateWatcher(aLdd);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
/**
* The CUsbOtgStateWatcher::~CUsbOtgStateWatcher method
*
* Destructor
*
* @internalComponent
*/
CUsbOtgStateWatcher::~CUsbOtgStateWatcher()
{
LOG_FUNC
Cancel();
RProperty::Delete(KUsbOtgStateProperty);
}
void CUsbOtgStateWatcher::ConstructL()
/**
* Performs 2nd phase construction of the OTG object.
*/
{
LOG_FUNC
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)
{
LOG_FUNC
iOtgState = RUsbOtgDriver::EStateReset;
}
/**
* Called when the OTG State change is reported
*/
void CUsbOtgStateWatcher::RunL()
{
LOG_FUNC
LOGTEXT2(_L8(">>CUsbOtgStateWatcher::RunL [iStatus=%d]"), iStatus.Int());
LEAVEIFERRORL(iStatus.Int());
Post();
LOGTEXT(_L8("<<CUsbOtgStateWatcher::RunL"));
}
/**
* Automatically called when the OTG State watcher is cancelled.
*/
void CUsbOtgStateWatcher::DoCancel()
{
LOG_FUNC
iLdd.CancelOtgStateNotification();
}
/**
* Sets state watcher in active state
*/
void CUsbOtgStateWatcher::Post()
{
LOG_FUNC
LOGTEXT(_L8("CUsbOtgStateWatcher::Post() - About to call QueueOtgStateNotification"));
iLdd.QueueOtgStateNotification(iOtgState, iStatus);
LOGTEXT3(_L8(">>CUsbOtgStateWatcher::RunL [iStatus=%d], iOtgState = %d"), iStatus.Int(), iOtgState);
if (RProperty::Set(KUidUsbManCategory,KUsbOtgStateProperty,(TInt)iOtgState) != KErrNone)
{
LOGTEXT3(_L8(">>CUsbOtgStateWatcher::RunL [iStatus=%d], iOtgState = %d - failed to set the property"), iStatus.Int(), iOtgState);
}
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)
{
LOG_STATIC_FUNC_ENTRY
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()
{
LOG_FUNC
Cancel();
}
void CUsbOtgEventWatcher::ConstructL()
/**
* Performs 2nd phase construction of the OTG object.
*/
{
LOG_FUNC
}
/**
* 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,
RUsbOtgDriver::TOtgEvent& aOtgEvent)
: CUsbOtgBaseWatcher(aLdd), iOwner(aOwner), iOtgEvent(aOtgEvent)
{
LOG_FUNC
}
/**
* Called when the OTG Event is reported
*/
void CUsbOtgEventWatcher::RunL()
{
LOG_FUNC
LOGTEXT2(_L8(">>CUsbOtgEventWatcher::RunL [iStatus=%d]"), iStatus.Int());
LEAVEIFERRORL(iStatus.Int());
LOGTEXT2(_L8("CUsbOtgEventWatcher::RunL() - Otg Event reported: %d"), (TInt)iOtgEvent);
if ( ( iOtgEvent == RUsbOtgDriver::EEventHnpDisabled )
||( iOtgEvent == RUsbOtgDriver::EEventHnpEnabled )
||( iOtgEvent == RUsbOtgDriver::EEventSrpInitiated )
||( iOtgEvent == RUsbOtgDriver::EEventSrpReceived )
||( iOtgEvent == RUsbOtgDriver::EEventVbusRaised )
||( iOtgEvent == RUsbOtgDriver::EEventVbusDropped )
)
{
iOwner.NotifyOtgEvent();
LOGTEXT2(_L8("CUsbOtgEventWatcher::RunL() - The owner is notified about Otg Event = %d"), (TInt)iOtgEvent);
}
Post();
LOGTEXT(_L8("<<CUsbOtgEventWatcher::RunL"));
}
#ifndef __FLOG_ACTIVE
void CUsbOtgEventWatcher::LogEventText(RUsbOtgDriver::TOtgEvent /*aState*/)
{
}
#else
void CUsbOtgEventWatcher::LogEventText(RUsbOtgDriver::TOtgEvent aEvent)
{
switch (aEvent)
{
case RUsbOtgDriver::EEventAPlugInserted:
LOGTEXT(_L8(" ***** A-Plug Inserted *****"));
break;
case RUsbOtgDriver::EEventAPlugRemoved:
LOGTEXT(_L8(" ***** A-Plug Removed *****"));
break;
case RUsbOtgDriver::EEventVbusRaised:
LOGTEXT(_L8(" ***** VBus Raised *****"));
break;
case RUsbOtgDriver::EEventVbusDropped:
LOGTEXT(_L8(" ***** VBus Dropped *****"));
break;
case RUsbOtgDriver::EEventSrpInitiated:
LOGTEXT(_L8(" ***** SRP Initiated *****"));
break;
case RUsbOtgDriver::EEventSrpReceived:
LOGTEXT(_L8(" ***** SRP Received *****"));
break;
case RUsbOtgDriver::EEventHnpEnabled:
LOGTEXT(_L8(" ***** HNP Enabled *****"));
break;
case RUsbOtgDriver::EEventHnpDisabled:
LOGTEXT(_L8(" ***** HNP Disabled *****"));
break;
case RUsbOtgDriver::EEventRoleChangedToHost:
LOGTEXT(_L8(" ***** Role Changed to Host *****"));
break;
case RUsbOtgDriver::EEventRoleChangedToDevice:
LOGTEXT(_L8(" ***** Role Changed to Device *****"));
break;
case RUsbOtgDriver::EEventRoleChangedToIdle:
LOGTEXT(_L8(" ***** Role Changed to Idle *****"));
break;
default:
break;
}
}
#endif
/**
* Automatically called when the OTG Event watcher is cancelled.
*/
void CUsbOtgEventWatcher::DoCancel()
{
LOG_FUNC
iLdd.CancelOtgEventRequest();
}
/**
* Sets state watcher in active state
*/
void CUsbOtgEventWatcher::Post()
{
LOG_FUNC
LOGTEXT(_L8("CUsbOtgEventWatcher::Post() - About to call QueueOtgEventRequest"));
iLdd.QueueOtgEventRequest(iOtgEvent, iStatus);
SetActive();
}
//-----------------------------------------------------------------------------
//----------------- OTG watcher class to monitor OTG Messages -----------------
//-----------------------------------------------------------------------------
/**
* The CUsbOtgWatcher::NewL method
*
* Constructs a new CUsbOtgWatcher object
*
* @internalComponent
* @param aOwner A reference to the object that owns the state watcher
* @param aLdd A reference to the USB Logical Device Driver
*
* @return A new CUsbOtgWatcher object
*/
CUsbOtgWatcher* CUsbOtgWatcher::NewL(MUsbOtgObserver& aOwner, RUsbOtgDriver& aLdd, TUint& aOtgMessage)
{
LOG_STATIC_FUNC_ENTRY
CUsbOtgWatcher* r = new (ELeave) CUsbOtgWatcher(aOwner, aLdd, aOtgMessage);
return r;
}
/**
* The CUsbOtgWatcher::~CUsbOtgWatcher method
*
* Destructor
*
* @internalComponent
*/
CUsbOtgWatcher::~CUsbOtgWatcher()
{
LOG_FUNC
LOGTEXT2(_L8(">CUsbOtgWatcher::~CUsbOtgWatcher (0x%08x)"), (TUint32) this);
Cancel();
}
/**
* The CUsbOtgWatcher::CUsbOtgWatcher method
*
* Constructor
*
* @param aOwner The device that owns the state watcher
* @param aLdd A reference to the USB Logical Device Driver
*/
CUsbOtgWatcher::CUsbOtgWatcher(MUsbOtgObserver& aOwner, RUsbOtgDriver& aLdd, TUint& aOtgMessage)
: CActive(CActive::EPriorityStandard), iOwner(aOwner), iLdd(aLdd), iOtgMessage(aOtgMessage)
{
LOG_FUNC
CActiveScheduler::Add(this);
}
/**
* Called when the OTG component changes its state.
*/
void CUsbOtgWatcher::RunL()
{
LOG_FUNC
if (iStatus.Int() != KErrNone)
{
LOGTEXT2(_L8("CUsbOtgWatcher::RunL() - Error = %d"), iStatus.Int());
return;
}
LOGTEXT2(_L8("CUsbOtgWatcher::RunL() - Otg Message reported: %d"), iOtgMessage);
iOwner.NotifyMessage();
Post();
}
/**
* Automatically called when the state watcher is cancelled.
*/
void CUsbOtgWatcher::DoCancel()
{
LOG_FUNC
iLdd.CancelOtgMessageRequest();
}
/**
* Instructs the state watcher to start watching.
*/
void CUsbOtgWatcher::Start()
{
LOG_FUNC
Post();
}
/**
* Sets state watcher in active state
*/
void CUsbOtgWatcher::Post()
{
LOG_FUNC
LOGTEXT(_L8("CUsbOtgWatcher::Post() - About to call QueueOtgMessageRequest"));
iLdd.QueueOtgMessageRequest((RUsbOtgDriver::TOtgMessage&)iOtgMessage, iStatus);
SetActive();
}
//-----------------------------------------------------------------------------
//------ A watcher class to monitor the P&S property for VBus marshalling -----
//-----------------------------------------------------------------------------
CRequestSessionWatcher* CRequestSessionWatcher::NewL(MUsbOtgObserver& aOwner)
{
CRequestSessionWatcher* self = new(ELeave) CRequestSessionWatcher(aOwner);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
CRequestSessionWatcher::~CRequestSessionWatcher()
{
Cancel();
iProp.Close();
}
void CRequestSessionWatcher::ConstructL()
/**
* Performs 2nd phase construction of the OTG object.
*/
{
LOG_FUNC
TInt err = RProperty::Define(KUsbRequestSessionProperty, RProperty::EInt, KAllowAllPolicy, KRequestSessionPolicy);
if ( err != KErrNone && err != KErrAlreadyExists )
{
User::LeaveIfError(err);
}
err = RProperty::Set(KUidUsbManCategory,KUsbRequestSessionProperty,0);
if ( err != KErrNone )
{
User::LeaveIfError(err);
}
User::LeaveIfError(iProp.Attach(KUidUsbManCategory, KUsbRequestSessionProperty));
iProp.Subscribe(iStatus);
SetActive();
}
CRequestSessionWatcher::CRequestSessionWatcher(MUsbOtgObserver& aOwner)
: CActive(CActive::EPriorityStandard), iOwner(aOwner)
{
LOG_FUNC
CActiveScheduler::Add(this);
}
/**
* Called when the OTG Event is reported
*/
void CRequestSessionWatcher::RunL()
{
LOG_FUNC
LOGTEXT2(_L8(">>CRequestSessionWatcher::RunL [iStatus=%d]"), iStatus.Int());
RDebug::Printf(">>CRequestSessionWatcher::RunL [iStatus=%d]", iStatus.Int());
iProp.Subscribe(iStatus);
SetActive();
TInt val;
User::LeaveIfError(iProp.Get(val));
RDebug::Printf(">>value=%d", val);
iOwner.NotifyMessage(KUsbMessageRequestSession);
LOGTEXT(_L8("<<CRequestSessionWatcher::RunL"));
}
/**
* Automatically called when the OTG Event watcher is cancelled.
*/
void CRequestSessionWatcher::DoCancel()
{
LOG_FUNC
iProp.Cancel();
}
//---------------------------- Connection Idle watcher class ---------------------------
/**
* The CUsbOtgConnectionIdleWatcher::NewL method
*
* Constructs a new CUsbOtgWatcher object
*
* @internalComponent
* @param aLdd A reference to the USB Logical Device Driver
*
* @return A new CUsbOtgWatcher object
*/
CUsbOtgConnectionIdleWatcher* CUsbOtgConnectionIdleWatcher::NewL(RUsbOtgDriver& aLdd)
{
LOG_STATIC_FUNC_ENTRY
CUsbOtgConnectionIdleWatcher* self = new (ELeave) CUsbOtgConnectionIdleWatcher(aLdd);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
/**
* The CUsbOtgConnectionIdleWatcher::~CUsbOtgConnectionIdleWatcher method
*
* Destructor
*
* @internalComponent
*/
CUsbOtgConnectionIdleWatcher::~CUsbOtgConnectionIdleWatcher()
{
LOG_FUNC
Cancel();
RProperty::Delete(KUsbOtgConnectionIdleProperty);
}
/**
* Performs 2nd phase construction of the OTG object.
*/
void CUsbOtgConnectionIdleWatcher::ConstructL()
{
LOG_FUNC
TInt err = RProperty::Define(KUsbOtgConnectionIdleProperty, RProperty::EInt, KAllowAllPolicy, KNetworkControlPolicy);
if ( err != KErrNone && err != KErrAlreadyExists )
{
User::LeaveIfError(err);
}
err = RProperty::Set(KUidUsbManCategory,KUsbOtgConnectionIdleProperty,ETrue);
if ( err != KErrNone )
{
User::LeaveIfError(err);
}
}
/**
* The CUsbOtgConnectionIdleWatcher::CUsbOtgConnectionIdleWatcher method
*
* Constructor
*
* @param aLdd A reference to the USB Logical Device Driver
*/
CUsbOtgConnectionIdleWatcher::CUsbOtgConnectionIdleWatcher(RUsbOtgDriver& aLdd)
: CUsbOtgBaseWatcher(aLdd)
{
LOG_FUNC
}
/**
* Called when the Connection Idle status change is reported
*/
void CUsbOtgConnectionIdleWatcher::RunL()
{
LOG_FUNC
LOGTEXT2(_L8(">>CUsbOtgConnectionIdleWatcher::RunL [iStatus=%d]"), iStatus.Int());
LEAVEIFERRORL(iStatus.Int());
Post();
LOGTEXT(_L8("<<CUsbOtgConnectionIdleWatcher::RunL"));
}
/**
* Automatically called when the Connection Idle watcher is cancelled.
*/
void CUsbOtgConnectionIdleWatcher::DoCancel()
{
LOG_FUNC
iLdd.CancelOtgConnectionNotification();
}
/**
* Sets state watcher in active state
*/
void CUsbOtgConnectionIdleWatcher::Post()
{
LOG_FUNC
LOGTEXT(_L8("CUsbOtgConnectionIdleWatcher::Post() - About to call QueueOtgIdPinNotification"));
iLdd.QueueOtgConnectionNotification(iConnectionIdle, iStatus);
switch (iConnectionIdle)
{
case RUsbOtgDriver::EConnectionIdle:
case RUsbOtgDriver::EConnectionUnknown:
RProperty::Set(KUidUsbManCategory,KUsbOtgConnectionIdleProperty,ETrue);
LOGTEXT2(_L8(">>CUsbOtgConnectionIdleWatcher::Post [iConnectionIdle=%d] - property is set to 1"), iConnectionIdle);
break;
case RUsbOtgDriver::EConnectionBusy:
RProperty::Set(KUidUsbManCategory,KUsbOtgConnectionIdleProperty,EFalse);
LOGTEXT2(_L8(">>CUsbOtgConnectionIdleWatcher::Post [iConnectionIdle=%d] - property is set to 0"), iConnectionIdle);
break;
default:
LOGTEXT2(_L8(">>CUsbOtgConnectionIdleWatcher::Post [iConnectionIdle=%d] is unrecognized, re-request QueueOtgIdPinNotification"), iConnectionIdle);
break;
}
SetActive();
}