// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#include <hal.h>

#include <hal_data.h>

#include "tavsrcTimer.h"

#include "tavsrc.h"

static const TUint KMillion = 1000000;

CAdaptiveHighResPeriodic* CAdaptiveHighResPeriodic::NewL(MAdaptiveHighResPeriodicClient& aClient)

	{

	CAdaptiveHighResPeriodic* p = new (ELeave) CAdaptiveHighResPeriodic(aClient);

	CleanupStack::PushL(p);

	p->ConstructL();

	CleanupStack::Pop(p);

	return p;

	}

CAdaptiveHighResPeriodic::~CAdaptiveHighResPeriodic()

	{

	Cancel();

	}

CAdaptiveHighResPeriodic::CAdaptiveHighResPeriodic(MAdaptiveHighResPeriodicClient& aClient)

: CTimer(EPriorityStandard+1), iClient(aClient)

	{

	CActiveScheduler::Add(this);

	}

void CAdaptiveHighResPeriodic::ConstructL()

	{

	CTimer::ConstructL();

	HAL::Get(HALData::EFastCounterFrequency, iFastCounterFreq);

	HAL::Get(HALData::EFastCounterCountsUp, iFastCounterIncreases);

	RDebug::Printf("Timer HAL: FC Freq %d", iFastCounterFreq);

	if (iFastCounterIncreases)

		{

		RDebug::Printf("Timer HAL: FC increases");

		}

	else

		{

		RDebug::Printf("Timer HAL: FC decreases");

		}

	iFastCounterFreqUs = (TReal)iFastCounterFreq / KMillion;

	}

void CAdaptiveHighResPeriodic::Start(TTimeIntervalMicroSeconds32 aInterval)

	{

	RDebug::Printf("*** Start Timer");

	iInterval = aInterval;

	// calculate the number of fast counter ticks for the interval

	TReal intervalInCounts = iInterval.Int()*iFastCounterFreqUs;		

	TInt countChangeExpected = (TInt) intervalInCounts;

	// store any extra fractions of fast counter ticks

	iExtraCounts = intervalInCounts - countChangeExpected;

	iIntendedCountOnCallback = iFastCounterIncreases

								? User::FastCounter() + countChangeExpected

								: User::FastCounter() - countChangeExpected;

	StartTimer(aInterval);

	}

void CAdaptiveHighResPeriodic::RunL()

	{

	User::LeaveIfError(iStatus.Int());

	iClient.TimerEvent(*this);

	if (!IsActive())

		{

		TUint endCount = User::FastCounter();

		// are we fast or slow? positive = late, negative = early

		TInt varianceCount = iFastCounterIncreases

				? (TInt)((endCount - iIntendedCountOnCallback))

				: (TInt)((iIntendedCountOnCallback - endCount));

		// convert count to microsecs

		TInt varianceUs = varianceCount/iFastCounterFreqUs;

		TInt nextInterval = iInterval.Int() - varianceUs; // in musecs

		if (nextInterval < 0)

			{

			nextInterval = 0;

			}

		// calculate the number of fast counter ticks for the interval

		TReal intervalInCounts = nextInterval*iFastCounterFreqUs;		

		TInt countChangeExpected = (TInt) intervalInCounts;

		// update extra fractions of fast counter ticks

		iExtraCounts += intervalInCounts - countChangeExpected;

		if (iExtraCounts >= 1)

			{

			// we have more than a whole tick, do the adjustment

			countChangeExpected++;

			iExtraCounts--;

			nextInterval = countChangeExpected/iFastCounterFreqUs;

			}

		iIntendedCountOnCallback = iFastCounterIncreases

									? User::FastCounter() + countChangeExpected

									: User::FastCounter() - countChangeExpected;

		StartTimer(nextInterval);

		}

	}

TInt CAdaptiveHighResPeriodic::RunError(TInt aError)

	{

	iClient.TimerError(*this, aError);

	return KErrNone;

	}

void CAdaptiveHighResPeriodic::SetInterval(TTimeIntervalMicroSeconds32 aInterval)

	{

	iInterval = aInterval;

	}

void CAdaptiveHighResPeriodic::StartTimer(TTimeIntervalMicroSeconds32 aInterval)

	{

	HighRes(aInterval);

	}