// Copyright (c) 1996-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_dtim.cpp

 // Overview:

 // Test delta timers. 

 // API Information:

 // CDeltaTimer.

 // Details:

 // - Create a delta timer and queue a number of timed events with different time intervals.

 // The callback functions of the timed events perform various actions: 

 // - Requeuing itself

 // - Cancelling the previous or next timer

 // - Doing nothing

 // - Stopping the active scheduler

 // - Verifies the timed events are run correctly and orderly

 // - The callback for each timed event increments a counter each time they are run

 // - The counters are checked to check how many times each callback has been called

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32base.h>

 #include <e32base_private.h>

 #include <e32test.h>

 #include <e32hal.h>

 #include <e32def.h>

 #include <e32def_private.h>

 RTest test(_L("T_DTIM"));

 TInt theResults[10];

 TCallBack* theCallBacks;

 TDeltaTimerEntry TheTimers[10];

 CDeltaTimer* theTimer;

 class CMyActiveScheduler : public CActiveScheduler

 	{

 public:

 	void Error(TInt anError)const;

 	static CMyActiveScheduler* NewL();

 	};

 void CMyActiveScheduler::Error(TInt /*anError*/) const

 //

 //

 //

 	{

 	User::Panic(_L("MYActiveScheduler"),0);

 	}

 CMyActiveScheduler* CMyActiveScheduler::NewL()

 	{

 	return new(ELeave) CMyActiveScheduler;

 	}

 struct TDeltaTimerCallData

 	{

 	CDeltaTimer* iTimer;

 	TDeltaTimerEntry *iTimers;

 	TInt iIndex;

 	};

 TInt print(TAny* anArg)

 //

 // Null entry. Just prints and increments it's counter.

 //

 	{

 	TInt index=(TInt)anArg;

 	theResults[index]++;

 	test.Printf(_L("Callback %d\r\n"),index);

 	return 0;

 	}

 TInt cancelNext(TAny * anArg)

 //

 // Cancels the next entry - assumes it is valid.

 //

 	{

 	TInt index=(TInt)anArg;

 	theTimer->Remove(TheTimers[index+1]);

 	return print(anArg);

 	}

 TInt requeue(TAny * anArg)

 //

 // Note that a requeue will run once every 200 ms until stop is called.

 //

 	{

 	TTimeIntervalMicroSeconds32 tickPeriod;

 	UserHal::TickPeriod(tickPeriod);

 	const TInt K13Ticks = 13 * tickPeriod.Int();

 	TInt index=(TInt)anArg;

 	theTimer->Queue(K13Ticks*2/3,TheTimers[index]);

 	return print(anArg);

 	}

 TInt requeuePrevious(TAny * anArg)

 //

 // Requeue the previous entry (assumes previous entry is valid handle)

 //

 	{

 	TTimeIntervalMicroSeconds32 tickPeriod;

 	UserHal::TickPeriod(tickPeriod);

 	const TInt K13Ticks = 13 * tickPeriod.Int();

 	TInt index=(TInt)anArg - 1;

 	theTimer->Queue(K13Ticks,TheTimers[index]);

 	return print(anArg);

 	}

 TInt cancel2ndFollowing(TAny * anArg)

 //

 // Assumes that 2nd following timer handle is valid.

 //

 	{

 	TInt index=(TInt)anArg;

 	theTimer->Remove(TheTimers[index+2]);

 	return print(anArg);

 	}

 TInt stop(TAny * anArg)

 //

 // Stops the active schduler

 //

 	{

 	TInt index=(TInt)anArg;

 	theResults[index]++;

 	test.Printf(_L("Callback %d, stopping\r\n"),index);

 	CMyActiveScheduler::Stop();

 	return 0;

 	}

 TInt E32Main()

 //

 //

 //

 	{

 	CMyActiveScheduler* s=NULL;

 	TRAPD(ret,s=CMyActiveScheduler::NewL())

 	test(ret==KErrNone);

 	CActiveScheduler::Install(s);

 	test.Title();

 	test.Start(_L("Timer"));

 	__KHEAP_MARK;

 	TTimeIntervalMicroSeconds32 tickPeriod;

 	UserHal::TickPeriod(tickPeriod);

 	TRAP(ret,theTimer=CDeltaTimer::NewL(100, tickPeriod.Int()));

 	test(ret==KErrNone);

 	Mem::FillZ(theResults,10*sizeof(TInt));

 	TCallBack callBacks[10]=

 		{

 		/* 0 */ TCallBack(print,(TAny*)0),

 		/* 1 */ TCallBack(cancelNext,(TAny*)1),

 		/* 2 */ TCallBack(print,(TAny*)2),	// Gets cancelled

 		/* 3 */ TCallBack(print,(TAny*)3),		// Runs twice

 		/* 4 */ TCallBack(requeuePrevious,(TAny*)4),

 		/* 5 */ TCallBack(cancel2ndFollowing,(TAny*)5),

 		/* 6 */ TCallBack(print,(TAny*)6),

 		/* 7 */ TCallBack(cancelNext,(TAny*)7),	// Gets cancelled

 		/* 8 */ TCallBack(requeue,(TAny*)8),	// Runs twice, once on the same RunL as the stop

 		/* 9 */ TCallBack(stop,(TAny*)9),

 		};

 	theCallBacks=callBacks;

 	for (TInt i=0;i<10;i++)

 		TheTimers[i].Set(theCallBacks[i]);

 	const TInt K13Ticks = 13 * tickPeriod.Int();

 	theTimer->Queue(K13Ticks,TheTimers[0]);

 	theTimer->Queue(2*K13Ticks,TheTimers[1]);

 	theTimer->Queue(3*K13Ticks,TheTimers[2]);

 	theTimer->Queue(4*K13Ticks,TheTimers[3]);

 	theTimer->Queue(5*K13Ticks,TheTimers[4]);

 	theTimer->Queue(6*K13Ticks,TheTimers[5]);

 	theTimer->Queue(7*K13Ticks,TheTimers[6]);

 	theTimer->Queue(8*K13Ticks,TheTimers[7]);

 	theTimer->Queue(9*K13Ticks,TheTimers[8]);

 	theTimer->Queue(10*K13Ticks,TheTimers[9]);

 	CActiveScheduler::Start();

 	test(theResults[0]==1);

 	test(theResults[1]==1);

 	test(theResults[2]==0);

 	test(theResults[3]==2);

 	test(theResults[4]==1);

 	test(theResults[5]==1);

 	test(theResults[6]==1);

 	test(theResults[7]==0);

 	test(theResults[8]==2);

 	test(theResults[9]==1);

 	delete theTimer;

 	__KHEAP_MARKEND;

 	test.End();

 	return 0;

 	}