// Copyright (c) 1995-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\active\t_idle.cpp

 // Overview:

 // Test the CIdle class. A CIdle and CTimer run on the same active scheduler and

 // the test displays how their callback function and RunL respectively are called.

 // API Information:

 // CIdle 

 // Details:

 // - Create and install active scheduler.

 // - Create and start a timer, add this to the active scheduler, request an event

 // after a specified interval. The timer will reschedule itself for a finite

 // number of times, then it will cancel the CIdle object and then reschedule

 // itself again and eventually it will stop the active scheduler.

 // - Create a CIdle active object, start a background task that is encapsulated in

 // callback function. The CIdle will keep reschedule itself by always returning

 // TRUE from the callback.

 // - Output some text from timer's RunL and CIdle's callback to show when they are

 // called and how they interleave.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32test.h>

 enum {EIdlePriority=1000,EMoreIdlePriority=800};

 class CMyRequestManager : public CActiveScheduler

 	{

 public:

 	virtual void Error(TInt anError) const;

 	};

 class CMyTimer : public CTimer

 	{

 public:

 	static CMyTimer* New();

 	void Start();

 	virtual void RunL();

 protected:

 	CMyTimer(TInt aPriority);

 private:

 	enum {EMaxCount=10,EStopCount=5,ETimeReq=100000};

 	TInt iCount;

 	};

 LOCAL_D RTest test(_L("T_IDLE"));

 LOCAL_D CIdle* MoreIdle;

 LOCAL_D TInt TheCount=0;

 void CMyRequestManager::Error(TInt anError) const

 //

 // Called if any Run() method leaves.

 //

 	{

 	test.Panic(anError,_L("CMyRequestManager::Error"));

 	}

 CMyTimer* CMyTimer::New()

 //

 // Create a new CMyTimer.

 //

 	{

 	return(new CMyTimer(EIdlePriority));

 	}

 CMyTimer::CMyTimer(TInt aPriority)

 //

 // Constructor

 //

 	: CTimer(aPriority),iCount(0)

 	{}

 void CMyTimer::Start()

 //

 // The timer has completed.

 //

 	{

 	TRAPD(r, ConstructL());

 	test(r==KErrNone);

 	CActiveScheduler::Add(this);

 	After(ETimeReq);

 	}

 void CMyTimer::RunL()

 //

 // The timer has completed.

 //

 	{

 	iCount++;

 	test.Printf(_L("Timer %03d\n"),iCount);

 	if (iCount==EStopCount)

 		MoreIdle->Cancel();

 	if (iCount<EMaxCount)

 		After(ETimeReq);

 	else

 		{

 		test.Printf(_L("\n"));

 		DoCancel();

 		CActiveScheduler::Stop();

 		}

 	}

 TInt IdleResponse(TAny*)

 //

 //	Respond to the idle callback

 //

 	{

 	test.Printf(_L("\rIdle response number : %6d "),++TheCount);

 	return(TRUE);

 	}

 TInt IdleCancel(TAny*)

 //

 //	Cancel the other idle object

 //

 	{

 	if (TheCount>9)

 		{

 		MoreIdle->Cancel();

 		return(FALSE);

 		}

 	return(TRUE);

 	}

 GLDEF_C TInt E32Main()

 //

 // Test idle objects.

 //

     {

 	test.Title();

 	test.Start(_L("Testing idle object cancellation"));

 //

 	CMyRequestManager* pR=new CMyRequestManager;

 	test(pR!=NULL);

 	CActiveScheduler::Install(pR);

 //

 	CMyTimer* pT=CMyTimer::New();

 	pT->Start();

 	MoreIdle=CIdle::New(EIdlePriority);

 	MoreIdle->Start(&IdleResponse);

 	CActiveScheduler::Start();	

 //

 	test.End();

 	return(0);

     }