// Copyright (c) 2005-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\emi\d_emitest.h

 // 

 //

 #ifndef __EMITEST_H__

 #define __EMITEST_H__

 #include <e32cmn.h>

 #include <e32ver.h>

 #ifndef __KERNEL_MODE__

 #include <e32std.h>

 #endif

 struct TUserTaskEventRecord

 	{

 	TUint8	iType;		//	Type of event, 	0 = Reschedule

 						//	1..127 = Reserved

 						//	> 127 = User Defined

 	TUint8	iFlags;		//	Includes:	

 						//Bit 0 - Events lost before this event. (All types) 

 	 					//Bit 1 - Previous thread now waiting. (Reschedule only)

 	TUint16	iExtra;		//This has no use in reschedule events, but may be used by other event types.

 	TUint32	iUserState;	//The state variable at the time of the event, which will probably indicate the clock frequency at the time of the event.

 	TUint32	iTime;		//Time that the event occurred.  Units defined by the GET_HIGH_RES_TICK macro.

 	TAny*	iPrevious;	//	The NThread that was executing before the switch.

 	TAny*	iNext;		//The NThread that was executing after the switch.

 	};

 const TInt KEMI_EventLost  =1;

 const TInt KEMI_PrevWaiting=2;

 _LIT(KEMITestName,"EMITEST");

 enum TMonitors

 	{

 	ENone,

 	ENormal,

 	EStressFirst,

 	EStressSecond

 	};

 class REMITest : public RBusLogicalChannel

 	{

 public:

 	enum TControl

 		{

 		ETaskEventLogging,

 		EGetTaskEvent,

 		EAddTaskEvent,

 		EGetIdleThread,

 		EGetSigmaThread,

 		ESetVEMSData,

 		EGetVEMSData,

 		ESetThreadLoggable,

 		EGetThreadLoggable,

 		ESetThreadTag,

 		EGetThreadTag,

 		ESetMask,

 		EGetMask,		

 		ESetDFC,

 		ESetState,

 		EGetState,

 		EGetNThread,

 		EAfterIdle

 		};

 	enum TRequest

 		{

 		ENumRequests,

 		EAllRequests = (1<<ENumRequests)-1

 		};

  public:

 	inline TInt Open();

 	inline TInt TaskEventLogging(TBool, TInt, TMonitors);

 	inline TBool GetTaskEvent(TUserTaskEventRecord&);

 	inline TBool AddTaskEvent(TUserTaskEventRecord&);

 	inline TAny* GetIdleThread();

 	inline TAny* GetSigmaThread();

 	inline void SetVEMSData(TAny* aThread, TAny* aData);

 	inline TAny* GetVEMSData(TAny* aThread);

 	inline void SetThreadLoggable(TAny* aThread, TBool aLoggable);

 	inline TBool GetThreadLoggable(TAny* aThread);

 	inline void SetThreadTag(TAny* aThread,TUint32 aTag);

 	inline TUint32 GetThreadTag(TAny* aThread);

 	inline void SetMask(TUint32 aMask);

 	inline TUint32 GetMask();	

 	inline void SetDfc();

 	inline void SetState(TInt);

 	inline TInt GetState();

 	inline TAny* GetNThread(const RThread&);

 	inline void AfterIdle(TInt);

 	};

 #ifndef __KERNEL_MODE__

 inline TInt REMITest::Open()

 	{ return DoCreate(KEMITestName,TVersion(1,0,1),KNullUnit,NULL,NULL); }

 inline TInt REMITest::TaskEventLogging(TBool aLogging, TInt aSize, TMonitors aMon)

 	{

 	 TInt param= aLogging?1:0;

 	 param |= (aMon<<1);	

 	 return DoControl(ETaskEventLogging,(TAny*)param,(TAny*)aSize); }  

 inline TBool REMITest::GetTaskEvent(TUserTaskEventRecord& aTask)

 	{ return (TBool) DoControl(EGetTaskEvent,&aTask); }	

 inline TBool REMITest::AddTaskEvent(TUserTaskEventRecord& aTask)

 	{ return (TBool) DoControl(EAddTaskEvent,&aTask); }	

 inline TAny* REMITest::GetIdleThread()

 	{ return (TAny*) DoControl(EGetIdleThread,NULL); }	

 inline TAny* REMITest::GetSigmaThread()

 	{ return (TAny*) DoControl(EGetSigmaThread,NULL); }	

 inline void REMITest::SetVEMSData(TAny* aThread, TAny* aData)

 	{ DoControl(ESetVEMSData,aThread, aData); }		

 inline TAny* REMITest::GetVEMSData(TAny* aThread)

 	{ return (TAny*) DoControl(EGetVEMSData,aThread); } 

 inline void REMITest::SetThreadLoggable(TAny* aThread, TBool aLoggable)

 	{ DoControl(ESetThreadLoggable,aThread, (TAny*) aLoggable); }	

 inline TBool REMITest::GetThreadLoggable(TAny* aThread)

 	{ return (TBool) DoControl(EGetThreadLoggable,aThread); }	

 inline void REMITest::SetThreadTag(TAny* aThread,TUint32 aTag)

 	{ DoControl(ESetThreadTag,aThread, (TAny*) aTag); }	

 inline TUint32 REMITest::GetThreadTag(TAny* aThread)

 	{ return DoControl(EGetThreadTag,aThread); }	

 inline void REMITest::SetMask(TUint32 aMask)

 	{ DoControl(ESetMask,(TAny*) aMask); }

 inline TUint32 REMITest::GetMask()

 	{ return DoControl(EGetMask,NULL); }		

 inline void REMITest::SetDfc()

 	{ DoControl(ESetDFC,NULL); }	

 inline void REMITest::SetState(TInt aState)

 	{ DoControl(ESetState,(TAny*) aState); }	

 inline TInt REMITest::GetState()

 	{ return DoControl(EGetState,NULL); }

 inline TAny* REMITest::GetNThread(const RThread& aRThread)

 	{return (TAny*) DoControl(EGetNThread,(TAny*)aRThread.Handle());}

 inline void REMITest::AfterIdle(TInt aDelay)

 	{ DoControl(EAfterIdle,(TAny*)aDelay);}

 #endif

 #endif