// 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