// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32test\resourceman\resourceman_psl\rescontrol_psl.cpp

// 

//

#include "rescontrol_psl.h"

TInt KSimulatedRCThreadPriority = 28;

#ifdef RESOURCE_MANAGER_SIMULATED_PSL

static DSimulatedPowerResourceController TheController;

#endif

//Resource controller creation

#ifdef RESOURCE_MANAGER_SIMULATED_PSL

DECLARE_STANDARD_PDD()

	{

	TInt r = DPowerResourceController::InitController();							

	if(r == KErrNone)

		return new DResConPddFactory;

	return NULL;																

	}

#endif

/** ISR function invoked when the specified amount of time expires. This is used for event driven resources. */

void DSimulatedPowerResourceController::TimerIsrFunc(TAny *ptr)

	{

	DSimulatedPowerResourceController *pC = (DSimulatedPowerResourceController *)ptr;

	//Queues a Dfc to signal fast semaphore.

	pC->iEventDfc.Add();

	}

/** DFC function to signal the fast semaphore. For event driven resources, the PIL is blocked until specified time (just 

	to simulate hardware event). */  

void DSimulatedPowerResourceController::EventDfcFunc(TAny *ptr)

	{

	DSimulatedPowerResourceController *pC = (DSimulatedPowerResourceController *)ptr;

	NKern::FSSignal((NFastSemaphore*)&pC->iEventFastSem);

	}

/** Constructor for simulated resource controller. */

DSimulatedPowerResourceController::DSimulatedPowerResourceController():DPowerResourceController(),iStaticResourceCount(0), iEventDfc(EventDfcFunc, this)

	{

	Kern::Printf(">DSimulatedPowerResourceController");

	}

/** Destructor for simulated resource controller. */

DSimulatedPowerResourceController::~DSimulatedPowerResourceController()

	{

	Kern::Printf("DSimulatedPowerResourceController::~DSimulatedPowerResourceController()\n");

	((TDynamicDfcQue*)iDfcQ)->Destroy();

	DStaticPowerResource *pR;

	TUint c;

	for(c = 0; c < iStaticResourceCount; c++)

		{

		pR = iResources[c];

		delete pR;

		}

	delete []iResources;

#ifdef PRM_ENABLE_EXTENDED_VERSION

	DStaticPowerResourceD* pDR;

	delete []iNodeArray; //Delete dependency nodes

	for(c = 0; c < iStaticResDependencyCount; c++) 

		{

		pDR = iDependencyResources[c];

		delete pDR;

		}

	delete []iDependencyResources;

#endif

	}

#ifdef PRM_ENABLE_EXTENDED_VERSION

//Function to return the controller pointer to use in extended psl file

DSimulatedPowerResourceController* GetControllerPtr()

	{

	return &TheController;

	}

#endif

/** This function is called from PIL, during resource controller creation phase.

	It creates a DFC queue and then invokes setDfcQ function to PIL to set the queue.

	It calls InitPools function of PIL to create the specified sizes of clients, 

	client levels and requests pools.

	*/

TInt DSimulatedPowerResourceController::DoInitController()

	{

	TInt r = KErrNone;

	Kern::Printf(">DSimulatedPowerResourceController::DoInitController()");

	//Create a DFC queue

	r = Kern::DynamicDfcQCreate((TDynamicDfcQue*&)iDfcQ, KSimulatedRCThreadPriority, KResmanName);

	if(r != KErrNone)

		{

		Kern::Printf("DFC Queue creation failed");

		return r;

		}

#ifdef CPU_AFFINITY_ANY

	NKern::ThreadSetCpuAffinity((NThread*)(iDfcQ->iThread), KCpuAffinityAny);			

#endif

	//Call the resource controller to set the DFCQ

	SetDfcQ(iDfcQ);

#ifdef PRM_ENABLE_EXTENDED_VERSION

	//Create a DFC Dependency Queue

	r = Kern::DynamicDfcQCreate((TDynamicDfcQue*&)iDfcQDependency, KSimulatedRCThreadPriority, 

									KResmanName);

	if(r != KErrNone)

		{

		Kern::Printf("DFC Dependency Queue creation failed");

		return r;

		}

	//Call the resource controller to set the DFCQDependency

	SetDfcQDependency(iDfcQDependency);

#endif

	//Init pools

	r = InitPools(KERNEL_CLIENTS, USER_CLIENTS, CLIENT_LEVELS, REQUESTS);

	return r;

	}

/** This function is used only for testing purpose to test the RegisterResorcesForIdle API

	ideally will be used by Power controller to obtain the state of the resources will be interested

	for idle power management.

	*/

EXPORT_C TInt DSimulatedPowerResourceController::CaptureIdleResourcesInfo(TUint aControllerId, TUint aNumResources, TPtr* aPtr)

	{

	Kern::Printf("DSimulatedPowerResourceController::CaptureIdleResourcesInfo\n");

	TInt r = TheController.RegisterResourcesForIdle(aControllerId, aNumResources, aPtr);

	return r;

	}

/** This function is used only for testing purpose. This is complete the initialization of resource controller.

	This is used to test the Postbootlevel and registration of static resource API's. 

	*/

EXPORT_C TInt DSimulatedPowerResourceController::CompleteResourceControllerInitialisation()

	{

	Kern::Printf("DSimulatedPowerResourceController::CompleteResourceControllerInitialisation()\n");

	return(TheController.InitResources());

	}

/** This function changes the state of the resource to appropriate value */

TInt DSimulatedPowerResourceController::ChangeResource(TPowerRequest& req, TInt& aCurrentLevel, TInt aMaxLevel, TInt aMinLevel)

	{

	DStaticPowerResource* pR = req.Resource();

	if(pR->Sense() == DStaticPowerResource::ECustom) //Custom sense set it to specified level

		{

		req.Level() = aCurrentLevel;

		}

	else if(pR->Sense() == DStaticPowerResource::EPositive) 

		{

		//Set it to value specified if valid, otherwise minimum or maximum based on the value.

		if(req.Level() > aMaxLevel)

			req.Level() = aMaxLevel;

		else if(req.Level() < aMinLevel)

			req.Level() = aMinLevel;

		aCurrentLevel = req.Level();

		}

	else

		{

		//Set it to value specified if valid, otherwise minimum or maximum based on the value.

		if( req.Level() < aMaxLevel)

			req.Level() = aMaxLevel;

		else if(req.Level() > aMinLevel)

			req.Level() = aMinLevel;

		aCurrentLevel = req.Level();

		}

	return KErrNone;

	}

/** This function processes all instantaneous resource types. Instantaneous resources should returned immediately, so 

	this function returns immediately after updating the value. */

TInt DSimulatedPowerResourceController::ProcessInstantaneousResources(TPowerRequest& req, TInt& aCurrentLevel, TInt aMaxLevel, TInt aMinLevel, TInt aDefaultLevel)

	{

	if(req.ReqType() == TPowerRequest::EGet)

		{

		req.Level() = aCurrentLevel;

		}

	else if(req.ReqType() == TPowerRequest::EChange)

		{

		return ChangeResource(req, aCurrentLevel, aMaxLevel, aMinLevel);

		}

	else if(req.ReqType() == TPowerRequest::ESetDefaultLevel)

		{

		req.Level() = aDefaultLevel;

		aCurrentLevel = aDefaultLevel;

		}

	else

		return KErrNotSupported;

	return KErrNone;

	}

/** Function used for polling resources. */

TBool PollingFunction(TAny* ptr)

	{

	static TInt count = 0;

	if(++count == (TInt)ptr)

		{

		count = 0;

		return ETrue;

		}

	return EFalse;

	}

/** This function processes polled resources. It waits for specified time and then performs requested operation

	if the specified operation is long latency operation.

	*/

TInt DSimulatedPowerResourceController::ProcessPolledResources(TPowerRequest& req, TInt&aCurrentLevel, TInt aMaxLevel, TInt aMinLevel, TInt aDefaultLevel, TInt aBlockTime)

	{

	DStaticPowerResource* pR = req.Resource();

	if(req.ReqType() == TPowerRequest::EGet)

		{

		if(!pR->LatencyGet())

			return ProcessInstantaneousResources(req, aCurrentLevel, aMaxLevel, aMinLevel, aDefaultLevel);

		Kern::PollingWait(PollingFunction, (TAny*)aBlockTime, 3, aBlockTime);

		req.Level() = aCurrentLevel;

		}

	else if(req.ReqType() == TPowerRequest::EChange)

		{

		if(!pR->LatencySet())

			return ProcessInstantaneousResources(req, aCurrentLevel, aMaxLevel, aMinLevel, aDefaultLevel);

		Kern::PollingWait(PollingFunction, (TAny*)aBlockTime, 3, aBlockTime);

		return ChangeResource(req, aCurrentLevel, aMaxLevel, aMinLevel);

		}

	else if(req.ReqType() == TPowerRequest::ESetDefaultLevel)

		{

		if(!pR->LatencySet())

			return ProcessInstantaneousResources(req, aCurrentLevel, aMaxLevel, aMinLevel, aDefaultLevel);

		Kern::PollingWait(PollingFunction, (TAny*)aBlockTime, 3, aBlockTime);

		req.Level() = aDefaultLevel;

		aCurrentLevel = aDefaultLevel;

		}

	else

		return KErrNotSupported;

	return KErrNone;

	}

/** This function processes event driven resources. It makes the calling function (PIL) to block on fast semaphore

	and starts the timer.The PIL is blocked until the timer expires. 

	*/

TInt DSimulatedPowerResourceController::ProcessEventResources(TPowerRequest& req, TInt& aCurrentLevel, TInt aMaxLevel, TInt aMinLevel, TInt aDefaultLevel, TInt aBlockTime)

	{

	DStaticPowerResource* pR = req.Resource();

	if(((req.ReqType() == TPowerRequest::EGet) && (!pR->LatencyGet())) || ((req.ReqType() == TPowerRequest::EChange) && (!pR->LatencySet())) || ((req.ReqType() == TPowerRequest::ESetDefaultLevel) && (!pR->LatencySet())))

		return ProcessInstantaneousResources(req, aCurrentLevel, aMaxLevel, aMinLevel, aDefaultLevel);	

	iEventFastSem.iOwningThread = (NThreadBase*)NKern::CurrentThread();

	iEventFastSem.iCount = 0;

	TInt timeout = NKern::TimerTicks(aBlockTime);

	NTimer iEventTimer(TimerIsrFunc, this);

	iEventTimer.OneShot(timeout);

	NKern::FSWait(&iEventFastSem);

	if(req.ReqType() == TPowerRequest::EGet)

		req.Level() = aCurrentLevel;

	else if(req.ReqType() == TPowerRequest::EChange)

		return ChangeResource(req, aCurrentLevel, aMaxLevel, aMinLevel);

	else if(req.ReqType() == TPowerRequest::ESetDefaultLevel)

		{

		req.Level() = aDefaultLevel;

		aCurrentLevel = aDefaultLevel;

		}

	else

		return KErrNotSupported;

	return KErrNone;

	}

//This registers all static resource with resource controller. This function is called by PIL

TInt DSimulatedPowerResourceController::DoRegisterStaticResources(DStaticPowerResource**& aStaticResourceArray, TUint16& aStaticResourceCount)

	{

	Kern::Printf(">DSimulatedPowerResourceController::DoRegisterStaticResources");

	aStaticResourceArray = (DStaticPowerResource**)new(DStaticPowerResource*[MAX_RESOURCE_COUNT]);

	if(!aStaticResourceArray)

		return KErrNoMemory;

	DStaticPowerResource* pR = NULL;

	//Create Binary Single Instantaneous Positive Resource

	pR = new DBSIGISPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel Single Instantaneous Positive Resource

	pR = new DMLSIGISPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Binary Single Instantaneous Negative Resource

	pR = new DBSIGISNResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel Single Instantaneous Negative Resource

	pR = new DMLSIGISNResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Binary Single Longlatency Positive Resource

	pR = new DBSLGLSPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel Single Longlatency  Positive Resource

	pR = new DMLSLGLSPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Binary Single Longlatency Get & Instantaneous Set Negative Resource

	pR = new DBSLGISNResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel Single Longlatency Get & Instantaneous Set Negative Resource

	pR = new DMLSLGISNResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Binary Single Instantaneous Get & Longlatency Set Positive Resource

	pR = new DBSIGLSPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel Single Instantaneous Get & Longlatency Set Positive Resource

	pR = new DMLSIGLSPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Binary SHared Instantaneous Positive Resource

	pR = new DBSHIGISPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel SHared Instantaneous Positive Resource

	pR = new DMLSHIGISPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Binary SHared Instantaneous Negative Resource

	pR = new DBSHIGISNResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel SHared Instantaneous Negative Resource

	pR = new DMLSHIGISNResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Binary SHared Longlatency Positive Resource

	pR = new DBSHLGLSPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel SHared Longlatency  Positive Resource

	pR = new DMLSHLGLSPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Binary SHared Longlatency Get & Instantaneous Set Negative Resource

	pR = new DBSHLGISNResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel SHared Longlatency Get & Instantaneous Set Negative Resource

	pR = new DMLSHLGISNResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create holes in resource array

	aStaticResourceArray[iStaticResourceCount++] = NULL;

	aStaticResourceArray[iStaticResourceCount++] = NULL;

	//Create Binary SHared Instantaneous Get & Longlatency Set Positive Resource

	pR = new DBSHIGLSPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Multilevel SHared Instantaneous Get & Longlatency Set Positive Resource

	pR = new DMLSHIGLSPResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	//Create Binary shared Longlatency get and set Custom Resource

	pR = new DBSHLGLSCResource();

	if(!pR)

		CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory)

	aStaticResourceArray[iStaticResourceCount++] = pR;

	iResources = aStaticResourceArray;

	aStaticResourceCount = iStaticResourceCount;

	return KErrNone;

	}

//Constructors of all resources

_LIT(KDBSIGISPResource, "SymbianSimulResource");

DBSIGISPResource::DBSIGISPResource() : DStaticPowerResource(KDBSIGISPResource, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0)

	{

	iFlags = KBinary;

	}

_LIT(KDMLSIGISPResource, "DMLSIGISPResource");

DMLSIGISPResource::DMLSIGISPResource() : DStaticPowerResource(KDMLSIGISPResource, 12), iMinLevel(10), iMaxLevel(75), iCurrentLevel(12)

	{

	iFlags = KMultiLevel;

	}

_LIT(KDBSIGISNResource, "DBSIGISNResource");

DBSIGISNResource::DBSIGISNResource() : DStaticPowerResource(KDBSIGISNResource, E_ON), iMinLevel(E_ON), iMaxLevel(E_OFF), iCurrentLevel(E_ON)

	{

	iFlags = KBinary | KSenseNegative;

	}

_LIT(KDMLSIGISNResource, "DMLSIGISNResource");

DMLSIGISNResource::DMLSIGISNResource() : DStaticPowerResource(KDMLSIGISNResource, 75), iMinLevel(75), iMaxLevel(10), iCurrentLevel(75)

	{

	iFlags = KMultiLevel | KSenseNegative;

	}

_LIT(KDBSLGLSPResource, "DBSLGLSPResource");

// change this state to OFF

DBSLGLSPResource::DBSLGLSPResource() : DStaticPowerResource(KDBSLGLSPResource, E_ON), iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(ETrue)

	{

	iFlags = KLongLatencyGet | KLongLatencySet;

	NKern::LockSystem();

	iBlockTime = 5; 

	NKern::UnlockSystem();

	}

_LIT(KDMLSLGLSPResource, "DMLSLGLSPResource");

DMLSLGLSPResource::DMLSLGLSPResource() : DStaticPowerResource(KDMLSLGLSPResource, 75), iMinLevel(10), iMaxLevel(75), iCurrentLevel(75), iPolled(EFalse)

	{

	iFlags = KMultiLevel | KLongLatencySet | KLongLatencyGet;

	iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME;

	}

_LIT(KDBSLGISNResource, "DBSLGISNResource");

DBSLGISNResource::DBSLGISNResource() : DStaticPowerResource(KDBSLGISNResource, E_ON), iMinLevel(E_ON), iMaxLevel(E_OFF), iCurrentLevel(E_ON), iPolled(ETrue)

	{

	iFlags = KLongLatencyGet | KSenseNegative;

	iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME;

	}

_LIT(KDMLSLGISNResource, "DMLSLGISNResource");

DMLSLGISNResource::DMLSLGISNResource() : DStaticPowerResource(KDMLSLGISNResource, 75), iMinLevel(75), iMaxLevel(10), iCurrentLevel(75), iPolled(EFalse)

	{

	iFlags = KMultiLevel | KLongLatencyGet | KSenseNegative;

	iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME;

	}

_LIT(KDBSIGLSPResource, "DBSIGLSPResource");

DBSIGLSPResource::DBSIGLSPResource() : DStaticPowerResource(KDBSIGLSPResource, E_ON), iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(ETrue)

	{

	iFlags = KBinary | KLongLatencySet;

	iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME;

	}

_LIT(KDMLSIGLSPResource, "DMLSIGLSPResource");

DMLSIGLSPResource::DMLSIGLSPResource() : DStaticPowerResource(KDMLSIGLSPResource, 75), iMinLevel(10), iMaxLevel(100), iCurrentLevel(75), iPolled(EFalse)

	{

	iFlags = KMultiLevel | KLongLatencySet;

	iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME;

	}

_LIT(KDBSHIGISPResource, "DBSHIGISPResource");

DBSHIGISPResource::DBSHIGISPResource() : DStaticPowerResource(KDBSHIGISPResource, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0)

	{

	iFlags = KBinary | KShared;

	}

_LIT(KDMLSHIGISPResource, "DMLSHIGISPResource");

DMLSHIGISPResource::DMLSHIGISPResource() : DStaticPowerResource(KDMLSHIGISPResource, 12), iMinLevel(10), iMaxLevel(75), iCurrentLevel(12)

	{

	iFlags = KMultiLevel | KShared;

	}

_LIT(KDBSHIGISNResource, "DBSHIGISNResource");

DBSHIGISNResource::DBSHIGISNResource() : DStaticPowerResource(KDBSHIGISNResource, E_ON), iMinLevel(E_ON), iMaxLevel(E_OFF), iCurrentLevel(E_ON)

	{

	iFlags = KBinary | KShared | KSenseNegative;

	}

_LIT(KDMLSHIGISNResource, "DMLSHIGISNResource");

DMLSHIGISNResource::DMLSHIGISNResource() : DStaticPowerResource(KDMLSHIGISNResource, 75), iMinLevel(75), iMaxLevel(10), iCurrentLevel(75)

	{

	iFlags = KMultiLevel | KShared | KSenseNegative;

	}

_LIT(KDBSHLGLSPResource, "DBSHLGLSPResource");

DBSHLGLSPResource::DBSHLGLSPResource() : DStaticPowerResource(KDBSHLGLSPResource, E_ON), iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(ETrue)

	{

	iFlags = KBinary | KShared | KLongLatencySet | KLongLatencyGet;

	iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME;

	}

_LIT(KDMLSHLGLSPResource, "DMLSHLGLSPResource");

DMLSHLGLSPResource::DMLSHLGLSPResource() : DStaticPowerResource(KDMLSHLGLSPResource, 70), iMinLevel(5), iMaxLevel(70), iCurrentLevel(70), iPolled(EFalse)

	{

	iFlags = KMultiLevel | KShared | KLongLatencySet | KLongLatencyGet;

	iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME;

	}

_LIT(KDBSHLGISNResource, "DBSHLGISNResource");