/*
* 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: Implementation
*
*/
#include <usbuinotif.h>
#include "cusbstatehostdelayhandle.h"
#ifndef STIF
#include "cusbnotifmanager.h"
#else
#include "mockcusbnotifmanager.h"
#endif
#include "errors.h"
#include "debug.h"
#include "panic.h"
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CUsbStateHostDelayHandle::CUsbStateHostDelayHandle(CUsbOtgWatcher* aWatcher) :
CUsbStateHostHandle(aWatcher)
{
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CUsbStateHostDelayHandle* CUsbStateHostDelayHandle::NewL(CUsbOtgWatcher* aWatcher)
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::NewL" ) );
CUsbStateHostDelayHandle* self = new (ELeave) CUsbStateHostDelayHandle(aWatcher);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::ConstructL()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::ConstructL" ) );
iTooMuchPowerTimer = CUsbTimer::NewL(this, ETooMuchPowerRequiredTimer);
iDriversNotFoundTimer = CUsbTimer::NewL(this, EDriversNotFoundTimer);
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CUsbStateHostDelayHandle::~CUsbStateHostDelayHandle()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::~CUsbStateHostDelayHandle" ) );
delete iTooMuchPowerTimer;
delete iDriversNotFoundTimer;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TUsbStateIds CUsbStateHostDelayHandle::Id()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::Id" ) );
return EUsbStateHostDelayHandle;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::JustAdvancedToThisStateL()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::JustAdvancedToThisStateL" ) );
// first do something specific to entering this state
// nothing by now, but something in the future
// then do general things, defined in superclass
CUsbStateHostHandle::JustAdvancedToThisStateL();
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::JustBeforeLeavingThisStateL()
{
iTooMuchPowerTimer->Cancel();
iDriversNotFoundTimer->Cancel();
// do general things for error handling
CUsbStateHostHandle::JustBeforeLeavingThisStateL();
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::DoHandleL()
{
FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::DoHandleL iWhat = %d" ), iWhat));
switch (iWhat)
{
case EUsbWatcherErrDriversNotFound:
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::DoHandleL DriversNotFound" ) );
iDriversNotFoundTimer->After(KTimeDriversNotFound);
break;
}
case EUsbWatcherErrDeviceRequiresTooMuchPowerOnEnumeration:
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::DoHandleL EUsbWatcherErrDeviceRequiresTooMuchPowerOnEnumeration" ) );
iTooMuchPowerTimer->After(KTimeTooMuchPowerRequired);
break;
}
default:
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::DoHandleL Pass request to CUsbStateHostHandle" ) );
Panic(EUnexpectedSituationToHandle);
break;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// From VBus observer
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::VBusUpL()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::VBusUpL" ) );
// this is not expected, due to in this state vbus already up, since entering the state
Panic(EVBusUpNotExpected);
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::VBusDownL()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::VBusDownL" ) );
// this is not expected, due to in this state vbus up during all the lifetime
Panic(EVBusDownNotExpected);
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::VBusErrorL()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::VBusErrorL" ) );
iWatcher->Usb().BusClearError();
HandleL(EUsbWatcherErrDeviceRequiresTooMuchPower, EUsbStateHostHandle);
}
// ---------------------------------------------------------------------------
// this will drop VBus in a while =>
// handle it in another state
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::AVBusErrorL()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::AVBusErrorL" ) );
HandleL(EUsbWatcherErrDeviceRequiresTooMuchPower, EUsbStateHostHandle);
}
// From Host Event notification observer
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::DeviceAttachedL(
TDeviceEventInformation aDevEventInfo)
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::DeviceAttachedL" ) );
ChangeHostStateL(EUsbStateHostAInitiate);
iWatcher->DeviceAttachedL(aDevEventInfo);
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::DeviceDetachedL(TDeviceEventInformation)
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::DeviceDetachedL" ) );
ChangeHostStateL(EUsbStateHostAInitiate);
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::BadHubPositionL()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::BadHubPositionL" ) );
HandleL(EUsbWatcherHubsNotSupported, EUsbStateHostHandle);
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::SrpReceivedL()
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::SrpReceivedL" ) );
// srp is not expected due to vbus is up in thes state
Panic(ESrpNotExpected);
}
// From TimerObserver
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CUsbStateHostDelayHandle::TimerElapsedL(TUsbTimerId aTimerId)
{
switch (aTimerId)
{
case ETooMuchPowerRequiredTimer:
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::TimerElapsedL - ETooMuchPowerRequiredTimer" ) );
HandleL(EUsbWatcherErrDeviceRequiresTooMuchPower, EUsbStateHostHandle);
break;
}
case EDriversNotFoundTimer:
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::TimerElapsedL - EDriversNotFoundTimer" ) );
HandleL(EUsbWatcherErrUnsupportedDevice, EUsbStateHostHandle);
break;
}
default:
{
FLOG( _L( "[USBOTGWATCHER]\tCUsbStateHostDelayHandle::TimerElapsedL - Unknown timer" ) );
Panic(EWrongTimerId);
}
}
}