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

// e32\euser\cbase\ub_tim.cpp

// 

//

#include "ub_std.h"

EXPORT_C CTimer::CTimer(TInt aPriority)

	: CActive(aPriority)

/**

Protected constructor with priority.

Use this constructor to set the priority of the active object.

Classes derived from CTimer must define and provide a constructor through 

which the priority of the active object can be passed. Such a constructor 

can call CTimer's constructor in its constructor initialisation list.

@param aPriority The priority of the timer.

*/

	{

	}

EXPORT_C CTimer::~CTimer()

/**

Destructor.

Frees resources prior to destruction. Specifically, it cancels any outstanding 

request and closes the RTimer handle.

*/

	{

	Cancel();

	iTimer.Close();

	}

EXPORT_C void CTimer::At(const TTime &aTime)

/**

Requests an event at a given local time.

This timer completes at the specified time - if the machine is in a 

turned off state at that time, the machine will be turned on again.

Notes:

1. The CTimer' RunL() function will be run as soon as possible after the

   specified  system time.

2. The RunL() may be delayed because the RunL() of another active object, with 

   the deepest nesting-level active scheduler on the same thread, is running 

   when the event occurs: this cannot be avoided, but can be minimised by

   making  all RunL()s of short duration.

3. The RunL() may be delayed because other, higher-priority, active objects are 

   scheduled instead. This can be avoided by making CTimers very high-priority.

4. The TTime object should be set to the home time.

@param aTime The local time at which the event is to occur.

@see TTime::HomeTime

*/

	{

	__ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded));

	iTimer.At(iStatus,aTime);

	SetActive();

	}

EXPORT_C void CTimer::AtUTC(const TTime &aTimeInUTC)

/**

Requests an event at a given UTC time.

This timer completes at the specified time - if the machine is in a 

turned off state at that time, the machine will be turned on again.

Notes:

1. The CTimer' RunL() function will be run as soon as possible after the

   specified  system time.

2. The RunL() may be delayed because the RunL() of another active object, with 

   the deepest nesting-level active scheduler on the same thread, is running 

   when the event occurs: this cannot be avoided, but can be minimised by

   making  all RunL()s of short duration.

3. The RunL() may be delayed because other, higher-priority, active objects are 

   scheduled instead. This can be avoided by making CTimers very high-priority.

4. The TTime object should be set to the universal time.

@param aTime The UTC time at which the event is to occur.

@see TTime::UniversalTime

*/

	{

	__ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded));

	iTimer.AtUTC(iStatus,aTimeInUTC);

	SetActive();

	}

EXPORT_C void CTimer::After(TTimeIntervalMicroSeconds32 anInterval)

/**

Requests an event after an interval.

This timer completes after the specified number of microseconds. The 

"after timer" counter stops during power-down. Therefore, a 5-second timer 

will complete late if the machine is turned off 2 seconds after the request 

is made.

Notes:

1. The CTimer's RunL() function will be run as soon as possible after the

   specified interval.

2. The RunL() may be delayed because the RunL() of another active object, with 

   the deepest nesting-level active scheduler on the same thread, is running 

   when the event occurs: this cannot be avoided, but can be minimised by

   making  all RunL()s of short duration.

3. The RunL() may be delayed because other, higher-priority, active objects are 

   scheduled instead. This can be avoided by making CTimers very high-priority.

@param anInterval Interval after which event is to occur, in microseconds.

@panic USER 87, if anInterval is negative. This is raised by the

       underlying RTimer.

@panic E32USER-CBase 51, if the active object has not been added to an

       active scheduler.

@see RTimer

*/

	{

	__ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded));

	iTimer.After(iStatus,anInterval);

	SetActive();

	}

EXPORT_C void CTimer::Lock(TTimerLockSpec aLock)

/** 

Requests an event on a specified second fraction.

Note that the RunL() function is run exactly on the specified second fraction.

@param aLock The fraction of a second at which the timer completes.

*/

	{

	__ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded));

	iTimer.Lock(iStatus,aLock);

	SetActive();

	}

EXPORT_C void CTimer::Inactivity(TTimeIntervalSeconds aSeconds)

/**

Requests an event if no activity occurs within the specified interval.

@param aSeconds The time interval.

*/

	{

	__ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded));

	iTimer.Inactivity(iStatus, aSeconds);

	SetActive();

	}

EXPORT_C void CTimer::HighRes(TTimeIntervalMicroSeconds32 aInterval)

/**

Requests an event after the specified interval to a resolution of 1ms. 

The "HighRes timer" counter stops during power-down (the same as "after timer"). 

@param aInterval  The time interval, in microseconds, after which an event

                  is to occur.

@panic USER 87, if anInterval is negative. This is raised by the

       underlying RTimer.

@panic KERN-EXEC 15, if this function is called while a request for a timer

       event is still outstanding.

*/

	{

	__ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded));

	iTimer.HighRes(iStatus, aInterval);

	SetActive();

	}

EXPORT_C void CTimer::ConstructL()

/**

Constructs a new asynchronous timer.

The function must be called before any timer requests (i.e. calls to

RTimer::After() or RTimer::At()) can be made.

Since it is protected, it cannot be called directly by clients of CTimer

derived classes. Typically, a derived class makes a base call to this function

in the second phase of two-phase construction; i.e. the derived class defines 

and implements its own ConstructL() function within which it makes a base 

call to CTimer::ConstructL().

*/

	{

	TInt r=iTimer.CreateLocal();

	if (r!=KErrNone)

		User::Leave(r);

	}

EXPORT_C void CTimer::DoCancel()

//

// Cancel the timer.

//

	{

	iTimer.Cancel();

	}

EXPORT_C CPeriodic *CPeriodic::New(TInt aPriority)

/**

Allocates and constructs a CPeriodic object - non-leaving.

Specify a high priority so the callback function is scheduled as soon as

possible after the timer events complete.

@param aPriority The priority of the active object. If timing is critical, 

                 it should be higher than that of all other active objects

                 owned by the scheduler.

@return Pointer to new CPeriodic object. The object is initialised and added 

        to the active scheduler. This value is NULL if there is insufficient

        memory.

*/

	{

	CPeriodic *pP=new CPeriodic(aPriority);

	if (pP)

		{

		TRAPD(r,pP->ConstructL());

		if (r==KErrNone)

			CActiveScheduler::Add(pP);

		else

			{

			delete pP;

			pP=NULL;

			}

		}

	return pP;

	}

EXPORT_C CPeriodic *CPeriodic::NewL(TInt aPriority)

/**

Allocates and constructs a CPeriodic object - leaving.

Specify a high priority so the callback function is scheduled as soon as

possible after the timer events complete.

@param aPriority The priority of the active object. If timing is critical, 

                 it should be higher than that of all other active objects

                 owned by the scheduler.

@return Pointer to new CPeriodic object. The object is initialised and added 

        to the active scheduler.

@leave KErrNoMemory There is insufficient memory to create the object.

*/

	{

	return((CPeriodic *)User::LeaveIfNull(New(aPriority)));

	}

EXPORT_C CPeriodic::CPeriodic(TInt aPriority)

	: CTimer(aPriority)

/**

Protected constructor with priority.

Use this constructor to set the priority of the active object.

Classes derived from CPeriodic must define and provide a constructor through 

which the priority of the active object can be passed. Such a constructor 

can call CPeriodic's constructor in its constructor initialisation list.

@param aPriority The priority of the timer.

*/

	{

	}

EXPORT_C CPeriodic::~CPeriodic()

/**

Destructor.

Frees resources prior to destruction.

*/

	{

	}

EXPORT_C void CPeriodic::Start(TTimeIntervalMicroSeconds32 aDelay,TTimeIntervalMicroSeconds32 anInterval,TCallBack aCallBack)

/**

Starts generating periodic events.

The event calls the protected RunL() function, 

which in turn calls the function specified by aCallBack. The first event is 

generated after aDelay microseconds; subsequent events are generated regularly 

thereafter at intervals of anInterval microseconds.

The TCallBack contains a function pointer and a TAny* pointer. The function 

will be repeatedly called with the pointer as a parameter.

Once started, periodic events are generated until the CPeriodic object is 

destroyed.

Notes:

1. The callback function will be run as soon as possible after the initial delay, 

   and after each period.

2. The callback may be delayed because the RunL() of another active object, with 

   the deepest nesting-level active scheduler on the same thread, is running 

   when the event occurs: this cannot be avoided, but can be minimised by making 

   all RunL()s of short duration.

3. The callback may be delayed because other, higher-priority, active objects 

   are scheduled instead. This can be avoided by giving the CPeriodic a very 

   high priority.

@param aDelay     The delay from the Start() function to the generation of the 

                  first event, in microseconds.

@param anInterval The interval between events generated after the initial

                  delay, in microseconds.

@param aCallBack  A callback specifying a function to be called when the CPeriodic 

                  is scheduled after a timer event.

@panic E32USER-CBase 52, if anInterval is negative.

@panic E32USER-CBase 53, if aDelay is negative.

*/

	{

	__ASSERT_ALWAYS(anInterval.Int()>=0,Panic(ETimIntervalNegativeOrZero));

	__ASSERT_ALWAYS(aDelay.Int()>=0,Panic(ETimDelayNegative));

	iInterval=anInterval.Int();

	iCallBack=aCallBack;

	After(aDelay);

	}

EXPORT_C void CPeriodic::RunL()

//

// Handle completion by issuing the next request and then calling back.

//

	{

	After(iInterval);

	iCallBack.CallBack();

	}

EXPORT_C CHeartbeat::CHeartbeat(TInt aPriority)

	: CTimer(aPriority)

/**

Protected constructor with a priority. Use this constructor to set the priority 

of the active object.

Classes derived from CHeartbeat must define and provide a constructor through 

which the priority of the active object can be passed. Such a constructor 

can call CHeartbeat's constructor in its constructor initialisation list.

@param aPriority The priority of the timer.

*/

	{}

EXPORT_C CHeartbeat *CHeartbeat::New(TInt aPriority)

/**

Allocates and constructs a CHeartbeat object - non-leaving.

Specify a high priority so the callback function is scheduled as soon as

possible after the timer events complete.

@param aPriority The priority of the active object. If timing is critical, 

                 it should be higher than that of all other active objects

                 owned by the scheduler.

@return Pointer to new CHeartbeat object. The object is initialised and added 

        to the active scheduler. This value is NULL if insufficient memory was

        available.

*/

	{

	CHeartbeat *pP=new CHeartbeat(aPriority);

	if (pP)

		{

		TRAPD(r,pP->ConstructL());

		if (r==KErrNone)

			CActiveScheduler::Add(pP);

		else

			{

			delete pP;

			pP=NULL;

			}

		}

	return pP;

	}

EXPORT_C CHeartbeat *CHeartbeat::NewL(TInt aPriority)

/**

Allocates and constructs a CHeartbeat object - leaving.

Specify a high priority so the callback function is scheduled as soon as

possible after the timer events complete.

@param aPriority The priority of the active object. If timing is critical, 

                 it should be higher than that of all other active objects

                 owned by the scheduler.

@return Pointer to new CHeartbeat object. The object is initialised and added 

        to the active scheduler.

*/

	{

	return((CHeartbeat *)User::LeaveIfNull(New(aPriority)));

	}

EXPORT_C CHeartbeat::~CHeartbeat()

/**

Destructor.

Frees resources prior to destruction.

*/

	{}

EXPORT_C void CHeartbeat::Start(TTimerLockSpec aLock, MBeating *aBeating)

/**

Starts generating heartbeat events. The event results in calls to the Beat() 

and Synchronize() functions specified by aBeating.

The first event is generated on the first fraction of a second corresponding 

to aLock that occurs after Start() has returned; subsequent events are generated 

regularly thereafter at one second intervals on the second fraction specified 

by aLock.

The aBeating mixin must be written by the user. Most of the time, its Beat() 

function is called which trivially updates the tick count. Occasionally, synchronisation 

is lost, and the Synchronize() function is called instead: this must find 

out from the system time how many ticks should have been counted, and update 

things accordingly.

Once started, heartbeat events are generated until the CHeartbeat object is 

destroyed.

@param aLock    The fraction of a second at which the timer completes.

@param aBeating Provides the Beat() and Synchronize() functions.

*/

	{

	iBeating=aBeating;

	iLock=aLock;

	Lock(aLock);

	}

EXPORT_C void CHeartbeat::RunL()

//

// Handle completion