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

// Rudimentary timer class that acts as an observer, which is used as a

// way to reduce the time duration from outside the Sim.Tsy.

// 

//

/**

 @file

*/

#include "csimtimer.h"

#include "CSimPhone.h"

const TInt KOneSecond=1000000;	// < Constant multipler to map integer duration to millisecond timer.

/**

Factory function used to create a timer object that can be signalled to

reduce its time.

@return A CSimTime object, which has the functionality to reduce the

        time duration being run.

@param aPhone The object created by this function is an observer which

              will be regitered with this CSimPhone object's

              CSimReduceTimers subject.

*/

CSimTimer* CSimTimer::NewL(CSimPhone* aPhone)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aPhone);

	CleanupStack::Pop(self);

	return self;

	}

/**

Second-phase construction of the timer.  Obtains the observer subject

from the CSimPhone object to ensure updates are made relative to all

timers.

@param aPhone The new observer will be regitered with this CSimPhone

              object's CSimReduceTimers subject.

*/

void CSimTimer::ConstructL(CSimPhone* aPhone)

	{

	iReduceTimersSubject = aPhone->GetReduceTimersSubject();

	}

/**

Default, first-phase, constructor for the timer (and observer) object.

*/

CSimTimer::CSimTimer()

				: CActive(EPriorityStandard), iRegistered(EFalse)

	{

	CActiveScheduler::Add(this);

	_LIT(KPanic,"CSimTimer::CSimTimer()");

	__ASSERT_ALWAYS(iTimer.CreateLocal() == KErrNone, User::Panic(KPanic,KErrGeneral));

	}

/**

Default destructor for CSimTimer.  Ensures the timer is unregistered as

an observer from its subject and cancels any outstanding requests.

*/

CSimTimer::~CSimTimer()

	{

	// Ensure that this observer is unregistered from its subject.

	if (iRegistered)

		{

		TRAP_IGNORE(iReduceTimersSubject->DetachL(this));

		}

	Cancel();

	iTimer.Close();

	}

/**

Starts the timer.  Waits for aDuration time, passed as a variable to

this function, before completing.

@param aDuration The duration time this timer should wait before

                 completing.

@param aCallback A pointer to the MTimerCallBack object which will be

                 notified when aDuration time passes.

*/

void CSimTimer::Start(TInt aDuration, MTimerCallBack* aCallback)

	{

	Start(aDuration,aCallback,KErrNotFound);

	}

/**

Starts the timer.  Waits for aDuration time, passed as a variable to

this function, before completing.

@param aDuration The duration time this timer should wait before

                 completing.

@param aCallback A pointer to the MTimerCallBack object which will be

                 notified when aDuration time passes.

@param aId An integer that will be passed to the aCallback object when

           the timer completes.  This can be used, by the component

           using this timer, to identify the purpose of the timer.

           This parameter is optional, thus, if not required

           Start(TInt, MTimerCallBack*) can be used.

*/

void CSimTimer::Start(TInt aDuration, MTimerCallBack* aCallback,TInt aId)

	{

	iCallBackId=aId;

	iCallback=aCallback;

	iDuration = aDuration;

	RegisterWithSubjectInCSimPhone();

	iStartTime.UniversalTime();

	iTimer.After(iStatus,aDuration*KOneSecond);

	SetActive();

	}

/**

Stops the timer events.

*/

void CSimTimer::DoCancel()

	{

	iTimer.Cancel();

	}

/**

Calls the MTimerCallBack::TimerCallBack function when the duration time

given to Start() completes.

*/

void CSimTimer::RunL()

	{

	iStartTime = 0;

	UnRegisterFromSubjectInCSimPhone();

	iCallback->TimerCallBack(iCallBackId);

	}

/**

Indicates whether the timer is running or not.

@return Etrue if the timer is running, Efalse otherwise.

*/

TBool CSimTimer::Running() const

	{

	return IsActive();

	}

/**

Function for obtaining the amount of time, in seconds, remaining on

this timer.

@return The number of remaining whole seconds on the duration of this

        timer.  This function can return error in very unlikely cases

        where time remaining is negative (KErrAbort), or if the number

        of elapsed seconds, from when the timer started, is too large

        for 32-bit integer (KErrOverflow).  KErrNotFound is returned if

        the timer is not running; e.g. if the timer has been cancelled.

*/

TInt CSimTimer::GetRemainingSeconds() const

	{

	if (!IsActive())

		{

		return KErrNotFound;

		}

	TTime endAt;

	endAt.UniversalTime();

	TTimeIntervalSeconds secsInterval;

	TInt err = endAt.SecondsFrom(iStartTime,secsInterval);

	if (err != KErrNone)

		{

		return err;

		}

	TInt timeElapsed = secsInterval.Int();

	if (timeElapsed < 0)

		{

		return KErrAbort;

		}

	return iDuration-timeElapsed;

	}

/**

Reduces the remaining time duration, of this timer, by the specified

number of seconds, which must be a number greater than or equal to the

remaining time on this timer, otherwise deduction will not be made.

Note: Although the CSimTimer object is registered on a call to Start,

it may stay registered even if the timer isn't running.  This can

happen when DoCancel() is called from outside this object.  In such a

case, any further Update() calls made to this object are ignored, since

Running() will be EFalse.

@param aSecsOffTimer Number of seconds to deduct off the remaining

                     duration of this timer.  This must be a number of

                     seconds greater than that remaining on the timer,

                     otherwise this method has no effect.

*/

void CSimTimer::Update(TInt aSecsOffTimer)

	{

	if (aSecsOffTimer < 0 || !IsActive())

		{

		return;

		}

	TInt remaining = GetRemainingSeconds();

	// Ensure there is enough time remaining to deduct aSeconds.

	// Also ensures that RemainingSeconds() does not return an error.

	if (remaining >= aSecsOffTimer)

		{

		Cancel();

		TInt newDelay = remaining - aSecsOffTimer;

		iTimer.After(iStatus,newDelay*KOneSecond);

		SetActive();

		}

	}

/**

Function for obtaining information about the event assocated with the timer

@return The timer event ID as defined in TTimerEventId in simtsy.h

*/

TInt CSimTimer::GetTimerEventInfo() const

	{

	return iCallBackId;

	}

/**

Registers observer to the subject obtained from the CSimPhone object,

given during construction.

*/

void CSimTimer::RegisterWithSubjectInCSimPhone()

	{

	if (!iRegistered)

		{

		TRAPD(err, iReduceTimersSubject->AttachL(this));

		if (err == KErrNone)

			{

			iRegistered = ETrue;

			}

		}

	}

/**

Unregisters observer from the subject obtained from the CSimPhone

object, given during construction.

*/

void CSimTimer::UnRegisterFromSubjectInCSimPhone()

	{

	if (iRegistered)

		{

		TRAPD(err, iReduceTimersSubject->DetachL(this));

		if (err == KErrNone)

			{

			iRegistered = EFalse;

			}

		}

	}