/*
* 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 part of UsbMan USB Class Framework.
*
*/
/**
@file
*/
#include <usb_std.h>
#include <cusbclasscontrolleriterator.h>
#include <musbclasscontrollernotify.h>
#include "CUsbDummyClassControllerLdd.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "CUsbDummyClassControllerLddTraces.h"
#endif
const TInt32 KDummyLDDTestServUid = 0x20031D88;
const TUint KCCErrorTestStepPublishedDeviceEventKey = 0x20031D6F;
// Panic codes
enum
{
// Bad value for the iSynchronicity member.
EDummyPanicBadSynchronicity = 0,
// Used for environment errors we do not handle.
EDummyPanicUnhandledError = 1,
// Used for bad iStatus and other state errors.
EDummyPanicBadState = 2,
// Error reading ini file.
EDummyPanicBadIniFile = 3,
// We already have our async request active.
EDummyPanicAlreadyActive = 4,
// We already have a request outstanding from the device class.
EDummyPanicOutstandingRequestFromDevice = 5,
// Attempt to call Start() when in illegal state
EDummyPanicBadApiCallStart = 6,
// Attempt to call Stop() when in illegal state
EDummyPanicBadApiCallStop = 7,
};
const TInt KDummyClassPriority = 1;
CUsbDummyClassControllerLdd* CUsbDummyClassControllerLdd::NewL(
MUsbClassControllerNotify& aOwner,
TUint aIndex)
/**
* Constructs a CUsbDummyClassControllerLdd object.
*
* @param aOwner USB Device that owns and manages the class
* @param aIndex The index number of the instance
* @return Ownership of a new CUsbDummyClassControllerLdd object
*/
{
CUsbDummyClassControllerLdd* self = new(ELeave) CUsbDummyClassControllerLdd(aOwner, aIndex);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
CUsbDummyClassControllerLdd::CUsbDummyClassControllerLdd(
MUsbClassControllerNotify& aOwner,
TUint aIndex)
/**
* Constructor.
*
* @param aOwner USB Device that owns and manages the class
* @param aIndex The index number of the instance
*/
: CUsbClassControllerPlugIn(aOwner, KDummyClassPriority),
iIndex(aIndex)
{
iState = EUsbServiceIdle; // needs explicit initialisation as non-zero
iPropertyExist = EFalse;
}
CUsbDummyClassControllerLdd::CUsbDummyClassControllerLdd(
MUsbClassControllerNotify& aOwner,
TUint aIndex, TInt aPriority)
/**
* Constructor.
*
* @param aOwner USB Device that owns and manages the class
* @param aIndex The index number of the instance
* @param aPriority a startup priority for the class controller
*/
: CUsbClassControllerPlugIn(aOwner, aPriority),
iIndex(aIndex)
{
iState = EUsbServiceIdle; // needs explicit initialisation as non-zero
iPropertyExist = EFalse;
}
void CUsbDummyClassControllerLdd::ConstructL()
/**
* Method to perform second phase construction.
*/
{
OstTraceFunctionEntry0( CUSBDUMMYCLASSCONTROLLERLDD_CONSTRUCTL_ENTRY );
OstTraceFunctionExit0( CUSBDUMMYCLASSCONTROLLERLDD_CONSTRUCTL_EXIT );
}
CUsbDummyClassControllerLdd::~CUsbDummyClassControllerLdd()
/**
* Destructor.
*/
{
OstTraceFunctionEntry0( CUSBDUMMYCLASSCONTROLLERLDD_CUSBDUMMYCLASSCONTROLLERLDD_ENTRY );
Cancel();
iPropertyExist = EFalse;
OstTraceFunctionExit0( CUSBDUMMYCLASSCONTROLLERLDD_CUSBDUMMYCLASSCONTROLLERLDD_EXIT );
}
void CUsbDummyClassControllerLdd::DoGetConfigL()
/**
* Reads the config from the ini file.
*/
{
}
void CUsbDummyClassControllerLdd::GetConfig()
/**
* Reads the config from the ini file.
* Note that this is assumed to succeed. Any failure will break the test and
* it's much cleaner to panic out of the test entirely rather than leave it to
* the user to figure out what's gone wrong.
*/
{
}
void CUsbDummyClassControllerLdd::Start(TRequestStatus& aStatus)
/**
* Called by UsbMan to start this class.
*
* @param aStatus Will be completed with success or failure.
*/
{
OstTraceFunctionEntry0( CUSBDUMMYCLASSCONTROLLERLDD_START_ENTRY );
CUsbClassControllerIterator *iterator = NULL;
TRAPD(ret,iterator = Owner().UccnGetClassControllerIteratorL());
if(ret == KErrNone)
{
delete iterator;
}
TRequestStatus* tmp = &aStatus;
User::RequestComplete(tmp, KErrNone);
if(!iPropertyExist)
{
TInt err = iProperty.Attach(TUid::Uid(KDummyLDDTestServUid),
KCCErrorTestStepPublishedDeviceEventKey);
iProperty.Subscribe(iStatus);
SetActive();
iPropertyExist = ETrue;
}
OstTraceFunctionExit0( CUSBDUMMYCLASSCONTROLLERLDD_START_EXIT );
}
void CUsbDummyClassControllerLdd::Stop(TRequestStatus& aStatus)
/**
* Called by UsbMan to stop this class.
*
* @param aStatus Will be completed with success or failure.
*/
{
OstTraceFunctionEntry0( CUSBDUMMYCLASSCONTROLLERLDD_STOP_ENTRY );
TRequestStatus* tmp = &aStatus;
User::RequestComplete(tmp, KErrNone);
OstTraceFunctionExit0( CUSBDUMMYCLASSCONTROLLERLDD_STOP_EXIT );
}
void CUsbDummyClassControllerLdd::GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const
/**
* Returns information about the interfaces supported by this class.
*
* @param aDescriptorInfo Will be filled in with interface information.
*/
{
aDescriptorInfo.iNumInterfaces = 0;
aDescriptorInfo.iLength = 0;
}
void CUsbDummyClassControllerLdd::RunL()
/**
* Standard active object RunL.
*/
{
OstTraceFunctionEntry0( CUSBDUMMYCLASSCONTROLLERLDD_RUNL_ENTRY );
TInt num;
iProperty.Get(num);
if(num < 0)
User::Leave(num);
iProperty.Subscribe(iStatus);
SetActive();
OstTraceFunctionExit0( CUSBDUMMYCLASSCONTROLLERLDD_RUNL_EXIT );
}
void CUsbDummyClassControllerLdd::DoCancel()
/**
* Standard active object cancellation function.
*/
{
iProperty.Cancel();
}
TInt CUsbDummyClassControllerLdd::RunError(TInt aError)
/**
* Standard active object error-handling function.
*
* Should return KErrNone to avoid an active scheduler panic. This function
* should never be called as there is another mechanism for catching errors.
*/
{
Owner().UccnError(KErrNone);
return KErrNone;
}
//
// End of file