// 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:
// timerlist.h
// 
//

/**
 @file
 @internalComponent 
*/

#include "timerlist.h"
#include "shmadebug.h"

CTimerList* CTimerList::NewL(TInt aPriority)
	{
	CTimerList* self = new(ELeave) CTimerList(aPriority);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

CTimerList::CTimerList(TInt aPriority) : CTimer(aPriority)
	{ 
	CActiveScheduler::Add(this);		
	}

CTimerList::~CTimerList()
	{
	Cancel();
	iTimerList.ResetAndDestroy();
	}

void CTimerList::ConstructL()
	{
	CTimer::ConstructL();
	}

TInt32 CTimerList::AddL(const TTimeIntervalMicroSeconds32& aInterval, const TCallBack& aCallBack)
	{
	TTimerInfo* info = new(ELeave) TTimerInfo;
	
	info->iCallBack = aCallBack;
	info->iTime.UniversalTime();
	info->iTime += TTimeIntervalMicroSeconds32(aInterval);
	
	AddL(info);
	
	return reinterpret_cast<TInt32>(info);
	}

TInt32 CTimerList::AddL(const TTime& aTime, const TCallBack& aCallBack)
	{
	TTimerInfo* info = new(ELeave) TTimerInfo;
	
	info->iCallBack = aCallBack;
	info->iTime = aTime;

	AddL(info);
	
	return reinterpret_cast<TInt32>(info);
	}

void CTimerList::AddL(const TTimerInfo* aInfo)
	{
	TInt64 last = 0;
	
	TInt count = iTimerList.Count();
	if (count > 0)
		{
		last = iTimerList[count-1]->iTime.Int64();
		}
	
	TLinearOrder<TTimerInfo> timerSortOrder(CTimerList::TimerSortOrder);
	
	iTimerList.InsertInOrderAllowRepeatsL(aInfo, timerSortOrder);
	
	// Only reset timer if necessary.
	count++;
	if (last != iTimerList[count-1]->iTime.Int64())
		{
		// reset timer to the new last-of-the-list
		Cancel();
		AtUTC(iTimerList[count-1]->iTime);
		}
	}
	
void CTimerList::Remove(TInt32 aTimer)
	{
	TInt index = iTimerList.FindInAddressOrder(reinterpret_cast<TTimerInfo*>(aTimer));
	
	if (index != KErrNotFound)
		{
		delete reinterpret_cast<TTimerInfo*>(aTimer);
		iTimerList.Remove(index);
		}
	}

void CTimerList::RunL()
	{ // Leavescan, this implementation of this method does not leave but further derived implementations may if they choose
	TTime now;

	now.UniversalTime();
	
	TInt count;

	for (count = iTimerList.Count(); 
		((count > 0) && (iTimerList[count-1]->iTime <= now));
		count--)
		{
		// Always remove from the end of the sorted list
		
		iTimerList[count-1]->iCallBack.CallBack();
		delete iTimerList[count-1];
		iTimerList.Remove(count-1);
		};
		
	// reschedule to run again at the expiry date of next repository on the list, if any
	count = iTimerList.Count();
	if (count > 0)
		{
		AtUTC(iTimerList[count-1]->iTime);
		}
	}

TInt CTimerList::TimerSortOrder(const TTimerInfo &aInfo1, const TTimerInfo &aInfo2)
	{
	return static_cast<TInt>(aInfo2.iTime.Int64() - aInfo1.iTime.Int64());
	}

TInt CTimerList::RunError(TInt aError)
	{
	DEBUGPRINT2(_L("CTimerList: RunError called with error=%d"), aError);

	// Current CTimerList::RunL()'s implementation doesn't leave so we are just returning KErrNone.
	// In case further derived implementations of this RunL() leaves, then this method can be changed 
	// to handle the error properly.
	aError = KErrNone;
	return aError;
	}