/*
 * Copyright (c) 2010 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
 *
 * Description:
 * This class contains implementation of CFlexTimerEngine.
 *
 */

// System include files
// None

// User include files
#include "flextimerengine.h"
#include "flextimercontainer.h"
#include "flextimerwakeuptimer.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "flextimerengineTraces.h"
#endif


// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CFlexTimerEngine* CFlexTimerEngine::NewL()
    {
    CFlexTimerEngine* self = new (ELeave) CFlexTimerEngine();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CFlexTimerEngine::~CFlexTimerEngine()
    {
    OstTrace0( TRACE_INTERNAL,
        CFLEXTIMERENGINE_CFLEXTIMERENGINE,
        "CFlexTimerEngine::~CFlexTimerEngine" );

    delete iFlexTimerContainer;
    delete iWakeUpTimer;
    }
// ---------------------------------------------------------------------------
// Add new timer and trap leave. Return Leave code to session.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFlexTimerEngine::AddTimer(
    const TTimeIntervalMicroSeconds& aWinStartInterval,
    const TTimeIntervalMicroSeconds& aWinEndInterval,
    TBool aCancelAtSystemTimeChange,
    const MFlexTimerServiceCB* aFlexTimerServiceCB )
    {
    TRAPD( err,
        iFlexTimerContainer->AddTimerL( aWinStartInterval,
            aWinEndInterval,
            aCancelAtSystemTimeChange,
            aFlexTimerServiceCB ) );

    if ( KErrNone == err )
        {
        StartTimer();
        }
    return err;
    }
// ---------------------------------------------------------------------------
// Remove timer from container queue and start new wakeup watch timer
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CFlexTimerEngine::CancelTimer(
    const MFlexTimerServiceCB* aFlexTimerServiceCB )
    {
    TInt error = iFlexTimerContainer->RemoveTimer( aFlexTimerServiceCB );
    StartTimer();
    
    return error;
    }

// ---------------------------------------------------------------------------
// Wakeup timer expired, Fire timers according to some algorithm set and
// restart wakeup timer.
// ---------------------------------------------------------------------------
//
void CFlexTimerEngine::WakeUp()
    {
    OstTrace0( TRACE_INTERNAL,
        CFLEXTIMERENGINE_WAKEUP,
        "CFlexTimerEngine::WakeUp" );
    
    iFlexTimerContainer->FireTimers(
        CFlexTimerContainer::EFlexTimerAlgorithmLatestPossible );

    StartTimer();
    }
// ---------------------------------------------------------------------------
// System time is changed. Abort all timers that need to be aborted and
// restart wakeup timer.
// ---------------------------------------------------------------------------
//
void CFlexTimerEngine::SystemTimeChanged()
    {
    OstTrace0( TRACE_INTERNAL,
        CFLEXTIMERENGINE_SYSTEMTIMECHANGED,
        "CFlexTimerEngine::SystemTimeChanged" );
    
    iFlexTimerContainer->AbortTimersDueToTimeChange( KErrAbort );
    StartTimer();
    }
// ---------------------------------------------------------------------------
// Private constructor
// ---------------------------------------------------------------------------
//
CFlexTimerEngine::CFlexTimerEngine() : iFlexTimerContainer( NULL ),
    iWakeUpTimer( NULL )
    {
    OstTrace0( TRACE_INTERNAL,
        DUP_CFLEXTIMERENGINE_CFLEXTIMERENGINE,
        "CFlexTimerEngine::CFlexTimerEngine" );
    //Nothing to do here
    }
// ---------------------------------------------------------------------------
// Private 2nd phase construction
// ---------------------------------------------------------------------------
//
void CFlexTimerEngine::ConstructL()
    {
    iFlexTimerContainer = CFlexTimerContainer::NewL();
    iWakeUpTimer = CFlexTimerWakeUpTimer::NewL( *this );
    }
// ---------------------------------------------------------------------------
// Stop timer just in case it is already running (e.g. after AddTimer())
// and Start new wakeup timer according to current situation in container
// queues If timeout window has passed fire timers right now.
// ---------------------------------------------------------------------------
//
void CFlexTimerEngine::StartTimer()
    {
    TTimeIntervalMicroSeconds nextTimeout;

    // Stop the timer, because, if there are no more pending timeouts, the
    // wake-up timer needs to be stopped. If timeouts are found, the timer is
    // is restarted below.
    iWakeUpTimer->StopTimer();

    if ( iFlexTimerContainer->GetNextTimeout( nextTimeout ) )
        {
        // If timeout is in the future, timer is started to wake up at that
        // moment.
        if ( nextTimeout > TTimeIntervalMicroSeconds( 0 ) )
            {
            iWakeUpTimer->StartTimer( nextTimeout );
            }
        // If timer is due now or in the past, Lets fire those right now.
        else
            {
            WakeUp();
            }
        }
    // Else no timers, so no need for timeouts. Server is propably about to be
    // deleted.
    }