// UB_TIM.CPP
//
// Copyright (c) 1995-1999 Symbian Ltd.  All rights reserved.
//

#include "ub_std.h"

EXPORT_C CTimer::CTimer(TInt aPriority)
//
// Constructor
//
	: CActive(aPriority)
	{

	__DECLARE_NAME(_S("CTimer"));
	}

EXPORT_C CTimer::~CTimer()
//
// Destructor
//
	{

	Cancel();
	iTimer.Close();
	}

EXPORT_C void CTimer::At(const TTime &aTime)
//
// Absolute timer.
//
	{

	__ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded));
	iTimer.At(iStatus,aTime);
	SetActive();
	}

EXPORT_C void CTimer::After(TTimeIntervalMicroSeconds32 anInterval)
//
// Relative timer.
//
	{

	__ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded));
	iTimer.After(iStatus,anInterval);
	SetActive();
	}

EXPORT_C void CTimer::Lock(TTimerLockSpec aLock)
//
// Relative timer.
//
	{

	__ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded));
	iTimer.Lock(iStatus,aLock);
	SetActive();
	}

EXPORT_C void CTimer::ConstructL()
//
// Open the timer.
//
	{

	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)
//
// Create a new periodic timer.
//
	{

	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)
//
// Create a new periodic timer with leave.
//
	{

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

EXPORT_C CPeriodic::CPeriodic(TInt aPriority)
//
// Constructor.
//
	: CTimer(aPriority)
	{

	__DECLARE_NAME(_S("CPeriodic"));
	}

EXPORT_C CPeriodic::~CPeriodic()
//
// Destructor.
//
	{
	}

EXPORT_C void CPeriodic::Start(TTimeIntervalMicroSeconds32 aDelay,TTimeIntervalMicroSeconds32 anInterval,TCallBack aCallBack)
//
// Start the periodic timer.
//
	{

	__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)
//
// Constructor
//
	: CTimer(aPriority)
	{}

EXPORT_C CHeartbeat *CHeartbeat::New(TInt aPriority)
//
// Create a new heartbeat timer
//
	{

	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)
//
// Create a new periodic timer with leave.
//
	{

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

EXPORT_C CHeartbeat::~CHeartbeat()
//
// Destructor
//
	{}

EXPORT_C void CHeartbeat::Start(TTimerLockSpec aLock, MBeating *aBeating)
//
// Start the heartbeat timer
//
	{

	iBeating=aBeating;
	iLock=aLock;
	Lock(aLock);
	}

EXPORT_C void CHeartbeat::RunL()
//
// Handle completion
//
	{
	
	TRequestStatus stat=iStatus;
	Lock(iLock);
	if (stat==KErrNone)
		iBeating->Beat();
	else
		iBeating->Synchronize();
	}