/*

* Copyright (c) 2007-2008 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:    Slideshow specific timer class

 *

*/

// INCLUDES

#include "shwtimer.h"

#include <glxlog.h>

#include <glxtracer.h>

// LOCAL CONSTANTS

namespace

	{

	// how many milliseconds go to microsecond

	const TInt KMultiplyMilli2Micro = 1000;

	}

// DEPENDENCIES

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

// Constructor.

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

inline CShwTimer::CShwTimer()

	: iPaused( EFalse ) // not paused by default

	{

	}

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

// NewL.

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

CShwTimer* CShwTimer::NewL( TInt aPriority )

	{

	TRACER("CShwTimer::NewL");

	GLX_LOG_INFO( "CShwTimer::NewL" );

	CShwTimer* self = new (ELeave) CShwTimer;

	CleanupStack::PushL( self );

	self->ConstructL( aPriority );

	CleanupStack::Pop( self );

	return self;

	}

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

// ConstructL.

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

void CShwTimer::ConstructL( TInt aPriority )

	{

	TRACER("CShwTimer::ConstructL");

	GLX_LOG_INFO( "CShwTimer::ConstructL" );

	iTimer = CPeriodic::NewL( aPriority );

	}

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

// Destructor.

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

CShwTimer::~CShwTimer()

	{

	TRACER("CShwTimer::~CShwTimer()");

    GLX_LOG_INFO( "CShwTimer::~CShwTimer" );

	Cancel();

	delete iTimer;

	}

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

// Start.

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

void CShwTimer::Start( TInt aDelay, TInt aInterval, TCallBack aCallback )

	{

	TRACER("CShwTimer::Start");

    GLX_LOG_INFO( "CShwTimer::Start" );

    // convert millisecond to microseconds

    TTimeIntervalMicroSeconds32 delay = aDelay * KMultiplyMilli2Micro;

    TTimeIntervalMicroSeconds32 interval = aInterval * KMultiplyMilli2Micro;

	// remember the callback

	iCallback = aCallback;

	// remember the interval

	iInterval = interval;

	// reset the time left in case start is called during pause

	iTimeLeft = delay;

	// No harm in cancelling the timer before start

	iTimer->Cancel();

	// if not paused, start the timer

	if( !iPaused )

		{

		// Get the current time

		iTimeTimerExpires.HomeTime();

		// Add the delay to determine the expiry time

		iTimeTimerExpires += iTimeLeft;

		// Start the timer

		iTimer->Start( iTimeLeft, iInterval, iCallback );

		}

	}

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

// Cancel.

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

void CShwTimer::Cancel()

	{

	TRACER("CShwTimer::Cancel");

    GLX_LOG_INFO( "CShwTimer::Cancel" );

	if ( iTimer )

		{

		iTimer->Cancel();

		}

	}

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

// Pause

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

void CShwTimer::Pause()

	{

	TRACER("CShwTimer::Pause");

    GLX_LOG_INFO( "CShwTimer::Pause" );

    // pause only if not yet paused

	if( !iPaused )

		{

		iPaused = ETrue;

		// take time left

		iTimeLeft = TimeLeft();

		//if the iTimeTimerExpires has already elapsed then we get -ve time left.In this case make it zero

		if(iTimeLeft.Int() <= 0)

		    {

		    iTimeLeft = 0;		    

		    }

        GLX_LOG_INFO1( "CShwTimer::Pause timeleft %d", iTimeLeft.Int() );

		// and cancel the timer

		iTimer->Cancel();

		}

	}

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

// Resume.

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

void CShwTimer::Resume()

	{

	TRACER("CShwTimer::Resume");

    GLX_LOG_INFO( "CShwTimer::Resume" );

    // resume only if paused

    if( iPaused )

    	{

		iPaused = EFalse;

		// if we had time left

		if( 0 <= iTimeLeft.Int() )		

			{

            GLX_LOG_INFO1( "CShwTimer::Resume timeleft %d", iTimeLeft.Int() );

			// start again, first for time left and after that with interval

			// NOTE: cant use Start as it takes time as milliseconds in a TInt

			// Get the current time

			iTimeTimerExpires.HomeTime();

			// Add the delay to determine the expiry time

			iTimeTimerExpires += iTimeLeft;

			// Start the timer

			iTimer->Start( iTimeLeft, iInterval, iCallback );

			}

    	}

	}

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

// TimeLeft.

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

TTimeIntervalMicroSeconds32 CShwTimer::TimeLeft()

	{

	TRACER("CShwTimer::TimeLeft");

    GLX_LOG_INFO( "CShwTimer::TimeLeft" );

	TTime timeNow;

	timeNow.HomeTime();

	// Difference between time now and the time at which timer should expire

	TTimeIntervalMicroSeconds remainingTime;

	remainingTime = iTimeTimerExpires.MicroSecondsFrom( timeNow );

	TTimeIntervalMicroSeconds32 timeLeft = I64INT( remainingTime.Int64() );

	// In case that 64 bit value is larger than 32 bits, just have the 

	// maximum 32 bit value

	if ( remainingTime > KMaxTInt32 )

		{

		timeLeft = TTimeIntervalMicroSeconds32( KMaxTInt32 );

		}

	return timeLeft;

	}

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

// IsActive.

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

TBool CShwTimer::IsActive()

	{

	TRACER("CShwTimer::IsActive");

	return iTimer->IsActive();

	}