/*
* 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();
}