// Copyright (c) 2005-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:

// Name          : timermanager.cpp

// Part of       : LightWeightTimer

// Version       : SIP/4.0

//

#include "SipAssert.h"

#include "TimerManager.h"

#include "timerrequest.h"

#include "timerstore.h"

#include "singletimer.h"

#include "timerlog.h"

// -----------------------------------------------------------------------------

// CTimerManager::NewL

// -----------------------------------------------------------------------------

//

CTimerManager* CTimerManager::NewL()

	{

	CTimerManager* self = CTimerManager::NewLC();	

	CleanupStack::Pop(self);

	return self;

	}

// -----------------------------------------------------------------------------

// CTimerManager::NewLC

// -----------------------------------------------------------------------------

//

CTimerManager* CTimerManager::NewLC()

	{

	CTimerManager* self = new (ELeave) CTimerManager();

	CleanupStack::PushL(self);	

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CTimerManager::CTimerManager

// -----------------------------------------------------------------------------

//

CTimerManager::CTimerManager() :

	iTimerIdCounter(KReservedTimer),

	iNowExpiring(EFalse)

	{

	}

// -----------------------------------------------------------------------------

// CTimerManager::ConstructL

// -----------------------------------------------------------------------------

//

void CTimerManager::ConstructL()

	{

	iTimerStore = CTimerStore::NewL();

	iTimer = CSingleTimer::NewL(*this);

	}

// -----------------------------------------------------------------------------

// CTimerManager::~CTimerManager

// -----------------------------------------------------------------------------

//

CTimerManager::~CTimerManager()

	{

	delete iTimerStore;

	delete iTimer;

	}

// -----------------------------------------------------------------------------

// CTimerManager::StartL

// -----------------------------------------------------------------------------

//

TTimerId

CTimerManager::StartL(MExpirationHandler* aObserver, TUint aMilliseconds)

	{

	__TEST_INVARIANT;

	__ASSERT_ALWAYS(aObserver, User::Leave(KErrArgument));

	return StartL(aObserver, aMilliseconds, NULL);

	}

// -----------------------------------------------------------------------------

// CTimerManager::StartL

// -----------------------------------------------------------------------------

//

TTimerId CTimerManager::StartL(MExpirationHandler* aObserver,

							   TUint aMilliseconds,

							   TAny* aTimerParam)

	{

	__TEST_INVARIANT;

	__ASSERT_ALWAYS(aObserver, User::Leave(KErrArgument));

    TTimerId newTimerId(NewTimerId());

#if defined(WRITE_TIMER_LOG)

	__SIP_INT_LOG2( "LwTimer StartL (id,duration)", newTimerId, aMilliseconds )

#endif

	iTimerStore->AddL(aObserver,

					  MillisecToTTime(aMilliseconds),

					  newTimerId,

					  aTimerParam);		

	//If iNowExpiring is true, timer can't be set now, as execution is inside

	//MExpirationHandler::TimerExpiredL. Timer will be set when the control

	//returns from callback to CTimerManager::TimerExpiredL.

	if (!iNowExpiring)

		{

		CheckIsNewTimerShortestL(newTimerId, aMilliseconds);

		}

	__TEST_INVARIANT;

	return newTimerId;

	}

// -----------------------------------------------------------------------------

// CTimerManager::Stop

// User is not allowed to stop the internal timer

// -----------------------------------------------------------------------------

//

TInt CTimerManager::Stop(TTimerId aTimerId)

	{

	__TEST_INVARIANT;

#if defined(WRITE_TIMER_LOG)

	__SIP_INT_LOG1( "LwTimer Stop, timer id", aTimerId)

#endif

	if (aTimerId == KReservedTimer)

		{

		return KErrNotFound;

		}

	TInt index(0);

	const CTimerRequest* timerReq = iTimerStore->SearchById(aTimerId, index);

	if (!timerReq)

		{

		return KErrNotFound;

		}

	if (!iTimerStore->Remove(index))

		{

		return KErrNotFound;

		}

	//If Stop is called from MExpirationHandler::TimerExpiredL, this condition

	//isn't true, as iTimer has TimerId of the expiring timer which was removed

	//from iTimerStore. So no need to check iNowExpiring flag now.

	if (aTimerId == iTimer->TimerId())

		{

		//The currently running timer was stopped.

		iTimer->Cancel();

		TRAPD(err, SetTimerWithShortestValueL());

		if (err != KErrNone)

			{

			return err;

			}

		}

	__TEST_INVARIANT;

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTimerManager::IsRunning

// Don't reveal the internal timer to user.

// -----------------------------------------------------------------------------

//

TBool CTimerManager::IsRunning(TTimerId aTimerId) const

	{

	__TEST_INVARIANT;

	if (aTimerId == KReservedTimer)

		{

		return EFalse;

		}

	TInt dummyIndex(0);

	return (iTimerStore->SearchById(aTimerId, dummyIndex) != NULL);

	}

// -----------------------------------------------------------------------------

// CTimerManager::ExpiresAfter

// -----------------------------------------------------------------------------

//

TInt CTimerManager::ExpiresAfter(

    TTimerId aTimerId, 

    TUint& aExpiresAfterInMillisecs) const

    {

    __TEST_INVARIANT;

    aExpiresAfterInMillisecs = 0;

    TInt index(0);

	const CTimerRequest* timerReq = iTimerStore->SearchById(aTimerId, index);

	if (!timerReq)

		{

		return KErrNotFound;

		}

	TTimeToMillisec(timerReq->ExpirationTime(), aExpiresAfterInMillisecs);

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTimerManager::TimerExpiredL

// SearchById can return NULL, e.g. in a following case:

// - User has set two timers with very similar durations and they are the only

//   currently running timers.

// - User stops the shorter timer, CTimerManager::Stop uses

//   SetTimerWithShortestValueL but as the remaining timer's expiration is so

//   close to the first timer, CSingleTimer uses CSingleTimer::ExpireImmediately

//-  Before CSingleTimer::RunL has chance to be executed, user stops also the

//   remaining timer, which is removed from CTimerStore.

//-  Soon CSingleTimer::RunL is called and leads here but the expiring timer has

//   already been removed and CTimerStore::SearchById returns NULL.

// -----------------------------------------------------------------------------

//

void CTimerManager::TimerExpiredL(TTimerId aTimerId)

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aTimerId != KNoSuchTimer, KErrArgument);

	TInt index(0);

	CTimerRequest* timerReq = iTimerStore->SearchById(aTimerId, index);

	if (timerReq)

		{

#if defined(WRITE_TIMER_LOG)

    __SIP_INT_LOG1( "LwTimer TimerExpiredL id", aTimerId )

#endif

		//Store callback and parameter before freeing timerReq

		MExpirationHandler* notifier = timerReq->Observer();

		TAny* timerParam = timerReq->TimerParam();

		//Remove expired item BEFORE calling TimerExpiredL.

		//If user stops the expiring timer withing TimerExpiredL, would crash

		//as the timer would be used here after TimerExpiredL.

		iTimerStore->Remove(index);

		//Notifier can be NULL for the internal timer

		if (notifier)

			{

			iNowExpiring = ETrue;

			notifier->TimerExpiredL(aTimerId, timerParam);

			iNowExpiring = EFalse;

			}		

		}

	SetTimerWithShortestValueL();

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CTimerManager::LeaveOccurred

// Do things that were not done in CTimerManager::TimerExpiredL due to leave.

// Clear iNowExpiring flag and start the next timer.

// -----------------------------------------------------------------------------

//

TInt CTimerManager::LeaveOccurred()

	{

    __TEST_INVARIANT;

	iNowExpiring = EFalse;

	TRAPD(err, SetTimerWithShortestValueL());

    __TEST_INVARIANT;

	return err;

	}

// -----------------------------------------------------------------------------

// CTimerManager::NewTimerId

// -----------------------------------------------------------------------------

//

TTimerId CTimerManager::NewTimerId()

	{

	__TEST_INVARIANT;

	iTimerIdCounter++;

	if (iTimerIdCounter == KNoSuchTimer || iTimerIdCounter == KReservedTimer)

		{

		iTimerIdCounter = KReservedTimer + 1;

		}

	__TEST_INVARIANT;

	return iTimerIdCounter;

	}

// -----------------------------------------------------------------------------

// CTimerManager::MillisecToTTime

// -----------------------------------------------------------------------------

//

TTime CTimerManager::MillisecToTTime(TUint aMilliseconds) const

	{

	__TEST_INVARIANT;

	TTime expirationTime;

	expirationTime.HomeTime();

	TTimeIntervalSeconds sec = aMilliseconds/1000;

	expirationTime += sec;

	TTimeIntervalMicroSeconds us = (TInt64)(aMilliseconds % 1000) * 1000;

	expirationTime += us;

	return expirationTime;

	}

// -----------------------------------------------------------------------------

// CTimerManager::TTimeToMillisec

// -----------------------------------------------------------------------------

//

TBool CTimerManager::TTimeToMillisec(TTime aTime, TUint& aMilliseconds) const

	{

	__TEST_INVARIANT;

	TTime now;

	now.HomeTime();

	TTimeIntervalSeconds deltaSeconds(0);

	if (aTime.SecondsFrom(now, deltaSeconds) != KErrNone)

		{

		return EFalse;

		}

	TTimeIntervalMicroSeconds deltaMicrosecs = aTime.MicroSecondsFrom(now);

	if (deltaSeconds.Int() < 0 || deltaMicrosecs.Int64() < 0)

		{

		//Timer should've already expired. Expire now. Can happen in debugger or

		//if there are so many short timers they can't be handled fast enough.

		aMilliseconds = 0;

		return ETrue;

		}

    // Set a value anyway but it should not be used for timer if EFalse is 

    // returned

    aMilliseconds = deltaSeconds.Int() * 1000;

	//"+ 1" is the worst case for the millisecond part

    if ((deltaSeconds.Int() + 1) > CSingleTimer::KMaxTimerAfterDuration / 1000)

		{

		return EFalse;

		}

	TInt64 milliseconds = (deltaMicrosecs.Int64()/1000) % 1000;

	//As milliseconds is always 0..999, the low 32 bits are enough

	aMilliseconds += I64LOW(milliseconds);

	return ETrue;

	}

// -----------------------------------------------------------------------------

// CTimerManager::CheckIsNewTimerShortestL

// If duration is too long for CSingleTimer::SetAfter, simulate it by chaining

// many shorter timers together. RTimer::At is avoided as it may end with

// KErrAbort ~23 minutes after setting it.

// -----------------------------------------------------------------------------

//

void CTimerManager::CheckIsNewTimerShortestL(TTimerId aTimerId,

											 TUint aMilliseconds)

	{

	__TEST_INVARIANT;

	TTimerId shortestTimerId(0);

	TTime shortestExpirationTime;

	if (iTimerStore->ShortestTimer(shortestTimerId, shortestExpirationTime))

		{

		if (shortestTimerId == aTimerId)

			{

			//The new timer is shorter than any of the existing, stop iTimer and

			//start it with the new expiration time.

			iTimer->Cancel();

            if (aMilliseconds <= CSingleTimer::KMaxTimerAfterDuration)

				{

				iTimer->SetAfter(aMilliseconds, aTimerId);

				}

			else

				{

				SetInternalTimerL();

				}

			}

		}

	else

		{

		//There must be at least one timer (the one just created).

		__ASSERT_DEBUG(EFalse,

			User::Panic(_L("TimerMgr:CheckIsNewTimerShortestL no timers"),

						KErrNotFound));

		}

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CTimerManager::SetTimerWithShortestValueL

// -----------------------------------------------------------------------------

//

void CTimerManager::SetTimerWithShortestValueL()

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(!iTimer->IsActive(), KErrNotReady);

	TTimerId timerId(0);

	TTime expirationTime;

	if (iTimerStore->ShortestTimer(timerId, expirationTime))

		{

		TUint milliseconds(0);

		if (TTimeToMillisec(expirationTime, milliseconds))

			{

			iTimer->SetAfter(milliseconds, timerId);

			}

		else

			{

			SetInternalTimerL();

			}

		}

#if defined(WRITE_TIMER_LOG)

	__SIP_INT_LOG1( "LwTimer SetTimerWithShortestValueL id", timerId )

#endif

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CTimerManager::SetInternalTimerL

// -----------------------------------------------------------------------------

//

void CTimerManager::SetInternalTimerL() const

	{

    __TEST_INVARIANT;

	iTimerStore->AddL(NULL,

                      MillisecToTTime(CSingleTimer::KInternalTimerDuration),

					  KReservedTimer,

					  NULL);

    iTimer->SetAfter(CSingleTimer::KInternalTimerDuration, KReservedTimer);

	}

// -----------------------------------------------------------------------------

// CTimerManager::__DbgTestInvariant

// -----------------------------------------------------------------------------

//

void CTimerManager::__DbgTestInvariant() const

	{

	if (!iTimerStore || !iTimer)

		{

		User::Invariant();

		}

	}