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

    }