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

 // e32\euser\cbase\ub_dtim.cpp

 // 

 //

 #include "ub_std.h"

 /**

 Creates a new timed event queue with the specified active object priority.

 @param aPriority The priority of this active object.

 @return On successful return, a pointer to the queue of timed events.

 @publishedAll

 @released

 */

 EXPORT_C CDeltaTimer* CDeltaTimer::NewL(TInt aPriority)

 	{

 	TTimeIntervalMicroSeconds32 tickPeriod;

 	UserHal::TickPeriod(tickPeriod);

 	CDeltaTimer* timer = new(ELeave) CDeltaTimer(aPriority, tickPeriod.Int());

 	TInt err = timer->iTimer.CreateLocal();

 	if (err)

 		{

 		delete timer;

 		User::Leave(err);

 		}

 	CActiveScheduler::Add(timer);

 	return timer;

 	}

 /**

 Creates a new timed event queue with the specified active object priority, and 

 the specified timer granularity.

 @param aPriority    The priority of this active object.

 @param aGranularity Ignored.  The resolution of the timer is the tick period.

 @return On successful return, a pointer to the queue of timed events.

 @publishedAll

 @deprecated

 */

 EXPORT_C CDeltaTimer* CDeltaTimer::NewL(TInt aPriority, TTimeIntervalMicroSeconds32 /*aGranularity*/)

 	{

 	return CDeltaTimer::NewL(aPriority);

 	}

 /**

 Constructor taking an active object priority value.

 The constructor sets this active object's priority value through a call to 

 the base class constructor in its c'tor list.

 @param aPriority    The priority of this active object.

 @param aTickPeriod  The period of a tick on the system.

 @internalComponent

 @released

 */

 CDeltaTimer::CDeltaTimer(TInt aPriority, TInt aTickPeriod)

 	: CActive(aPriority), iTickPeriod(aTickPeriod)

 	{

 	}

 /**

 Adds a new timed event entry into the timed event queue.

 @param aTimeInMicroSeconds The interval from the present time when the timed 

 	                       event entry is to expire.

 @param aEntry              The timed event entry encapsulating the call back that

                            is to be called when this timed event entry expires.

 @publishedAll

 @released

 */

 EXPORT_C void CDeltaTimer::Queue(TTimeIntervalMicroSeconds32 aTimeInMicroSeconds, TDeltaTimerEntry& aEntry)

 	{

 	QueueLong(TTimeIntervalMicroSeconds(MAKE_TINT64(0, aTimeInMicroSeconds.Int())), aEntry);

 	}

 /**

 Adds a new timed event entry into the timed event queue.

 @param aTimeInMicroSeconds The interval from the present time when the timed 

 	                       event entry is to expire.

 @param aEntry              The timed event entry encapsulating the call back that

                            is to be called when this timed event entry expires.

 @return KErrNone if sucessful, KErrOverflow if the interval is too great or negative.

 @publishedAll

 @released

 */

 EXPORT_C TInt CDeltaTimer::QueueLong(TTimeIntervalMicroSeconds aTimeInMicroSeconds, TDeltaTimerEntry& aEntry)

 	{

 	const TInt64 timeInTicks = (aTimeInMicroSeconds.Int64() + iTickPeriod - 1) / iTickPeriod;

 	TInt timeInTicks32 = I64LOW(timeInTicks);

 	// We are using deltas on tick values, hence using maximum signed number of ticks

 	if (I64HIGH(timeInTicks) || (timeInTicks32 < 0))

 		{

 		return KErrOverflow;

 		}

 	// Make sure we queue for at least one tick

 	if (timeInTicks32 == 0)

 		{

 		timeInTicks32 = 1;

 		}

 	// Calculate tick count for new entry

 	aEntry.iLink.iTickCount = Exec::TickCount() + timeInTicks32;

 	// Add this entry at the right spot

 	iQueue.Add(aEntry.iLink);

 	// Queue the timer, re-queuing if we've added to the head of the queue

 	Activate(&aEntry.iLink == iQueue.First());

 	return KErrNone;

 	}

 /**

 Issues a new RTimer request, if there is no outstanding request and the queue 

 is not empty.

 @internalComponent

 @released

 */

 void CDeltaTimer::Activate(TBool aRequeueTimer)

 //

 // Queue a request on the timer.

 //

 	{

 	if (IsActive())

 		{

 		if (aRequeueTimer)

 			{

 			Cancel();

 			}

 		else

 			{

 			return;

 			}		

 		}

 	if (!iQueue.IsEmpty() && !iQueueBusy)

 		{

 		SetActive();

 		const TInt ticksToWait = iQueue.First()->iTickCount - Exec::TickCount();

 		if (ticksToWait > 0)

 			{

 			iTimer.AfterTicks(iStatus, ticksToWait);

 			}

 		else

 			{

 			TRequestStatus* status = &iStatus;

 			User::RequestComplete(status, KErrNone);

 			}

 		}

 	}

 /**

 Deals with an RTimer completion event.

 The function inspects the timed event entry at the head of the queue, and 

 reduces its timer value by the appropriate amount. If this timed event is 

 now found to have expired, the call back function is called, and the timed 

 event entry removed from the queue.

 If the timed event entry has not expired, it remains at the head of the queue.

 The function issues a new RTimer request, using the timer granularity value 

 as the time interval.

 @see RTimer

 @see CActive

 @internalComponent

 @released

 */

 void CDeltaTimer::RunL()

 //

 // Call all zero delta callbacks

 	{

 	// Queue busy

 	iQueueBusy = ETrue;

 	// Whilst the list of expired timers is being processed, time will pass and

 	// the tick count may have increased such that there are now more expired

 	// timers.  Loop until we have either emptied the queue or can wait for a

 	// timer exipration in the future.

 	while (!iQueue.IsEmpty())

 		{

 		// Calculate how long till first timer expires

 		const TUint tickCount = Exec::TickCount();

 		// If the first timer is yet to expire, wait some more

 		if (((TInt)(iQueue.First()->iTickCount - tickCount)) > 0)

 			{

 			break;

 			}

 		// Remove entry before callback to prevent re-entrancy issues

 		TTickCountQueLink* entry = iQueue.RemoveFirst();

 		// Iterate through the timers we know have expired based on the

 		// last calculation of delta

 		while (entry)

 			{

 			// Make callback.  This could go reentrant on Queue[Long]() or Remove().

 			reinterpret_cast<TDeltaTimerEntry*>(

 				PtrSub(

 					entry,

 					_FOFF(TDeltaTimerEntry, iLink)

 				))

 			->iCallBack.CallBack();

 			// Remove the next expired entry, if any

 			entry = iQueue.RemoveFirst(tickCount);

 			}

 		}

 	// Queue idle

 	iQueueBusy = EFalse;

 	// Requeue timer

 	Activate();

 	}

 /**

 Implements cancellation of an oustanding RTimer request.

 @internalComponent

 @released

 */

 void CDeltaTimer::DoCancel()

 	{

 	iTimer.Cancel();

 	}

 /**

 Removes the specified timed event entry from the timer queue.

 @param aEntry The timed event entry.

 @publishedAll

 @released

 */

 EXPORT_C void CDeltaTimer::Remove(TDeltaTimerEntry& aEntry)

 	{

 	// Remove the specified entry from the list

 	aEntry.iLink.Deque();

 	}

 /**

 Destructor.

 Frees all resources before destruction of the object. Specifically, it cancels 

 any outstanding timer requests generated by the RTimer object and then deletes 

 all timed event entries from the timed event queue.

 @see RTimer

 @publishedAll

 @released

 */

 CDeltaTimer::~CDeltaTimer()

 	{

 	Cancel();

 	while (!iQueue.IsEmpty())

 		{

 		iQueue.First()->Deque();

 		}

 	iTimer.Close();

 	}