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

//

// INCLUDE FILES

#include <e32base.h>

#include "HWRMGenericTimer.h"

#include "HWRMtrace.h"

// ============================ MEMBER FUNCTIONS ===============================

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

// CHWRMGenericTimer::NewL

// Two-phased constructor.

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

//

CHWRMGenericTimer* CHWRMGenericTimer::NewL(MHWRMGenericTimerCallback& aCallback,

                                       const TTimeIntervalMicroSeconds32& aMaxTime,

                                       TInt aTimerId)

    {

    COMPONENT_TRACE4(_L( "HWRM Server - CHWRMGenericTimer::NewL(0x%x, 0x%x, 0x%x)" ), &aCallback, aMaxTime.Int(), aTimerId );

    CHWRMGenericTimer* self = new (ELeave) CHWRMGenericTimer(aCallback, aMaxTime, aTimerId);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMGenericTimer::NewL - return 0x%x" ), self );

    return self;

    }

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

// CHWRMGenericTimer::CHWRMGenericTimer

// Constructor with callback class as a parameter.

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

//

CHWRMGenericTimer::CHWRMGenericTimer(MHWRMGenericTimerCallback& aCallback, 

                                 const TTimeIntervalMicroSeconds32& aMaxTime,

                                 TInt aTimerId)

                            : CTimer(EPriorityHigh), 

                             iCallback(aCallback),

                             iMaximumTime(aMaxTime),

                             iCutOff(EFalse),

                             iTimerId(aTimerId)

    {

    COMPONENT_TRACE3(_L( "HWRM Server - CHWRMGenericTimer::CHWRMGenericTimer(0x%x, 0x%x)" ), &aCallback, aMaxTime.Int() );

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMGenericTimer::CHWRMGenericTimer - return" ) );

    }

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

// CHWRMGenericTimer::~CHWRMGenericTimer

// Destructor.

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

//

CHWRMGenericTimer::~CHWRMGenericTimer()

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMGenericTimer::~CHWRMGenericTimer()" ) );

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMGenericTimer::~CHWRMGenericTimer - return" ) );

    }

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

// CHWRMGenericTimer::Set

// Start the timer to complete after the specified number of microseconds.

// If the duration is zero, then timer is set to predefined maximum value.

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

//

void CHWRMGenericTimer::Set(const TTimeIntervalMicroSeconds32& aInterval)

    {

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMGenericTimer::Set(%d)" ), aInterval.Int() );

    __ASSERT_ALWAYS(CActiveScheduler::Current()!= NULL, User::Invariant());

    if (!IsAdded())

        {

        CActiveScheduler::Add(this);

        }

    // If the timer is already running, cancel it... 

    if (IsActive())

        {

        Cancel();

        }

    // And set the new timer. If timer has specified maximum time, enforce that.

    TTime now;

    now.UniversalTime();

    if ( iMaximumTime.Int() != 0 && (0 == aInterval.Int() || aInterval > iMaximumTime) ) 

        {

        // Maximum time has been specified, and interval parameter is such that 

        // it should be enforced

        iActivationTime = now + iMaximumTime;

        After(iMaximumTime);

        COMPONENT_TRACE2(_L( "HWRM Server - CHWRMGenericTimer::Set - Using Maximum time %d" ), iMaximumTime.Int() );

        iCutOff = ETrue;

        }

    else if ( iMaximumTime.Int() == 0 && aInterval.Int() == 0 )

        {

        // No maximum time specified and interval calls for infinite duration.

        // --> Do not set the timer at all.

        }

    else

        {    

        // Otherwise just set the time to specified interval.

        iActivationTime = now + aInterval;

        After(aInterval);

        iCutOff = EFalse;

        }

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMGenericTimer::Set - return" ) );

    }

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

// CHWRMGenericTimer::Freeze

// Stop timer and returns the remaining time

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

//

TTimeIntervalMicroSeconds32 CHWRMGenericTimer::Freeze()

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMGenericTimer::Freeze()" ));

    // Must use 64 bit version as no way to get TTimeIntervalMicroSeconds32 from TTime.

    TTimeIntervalMicroSeconds frozenTime = 0LL;

    if ( IsAdded() && IsActive() )

        {

        Cancel();

        TTime now;

        now.UniversalTime();

        frozenTime = iActivationTime.MicroSecondsFrom(now);

        if ( frozenTime.Int64() <= 0 )

            {

            // Should have activated by now, set freeze timer to 1 for instant activation

            // after unfreeze.

            frozenTime = 1LL;

            }

        }

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMGenericTimer::Freeze - return %d" ), frozenTime.Int64() );    

    // Loss of precision ok, as frozentime never exceeds 32 bits.    

    return frozenTime.Int64();

    }

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

// CHWRMGenericTimer::RunL

// RunL() function will be run after the specified system time expires,

// i.e. time is set by After() method,

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

void CHWRMGenericTimer::RunL()

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMGenericTimer::RunL()" ));

    iCallback.GenericTimerFired(iTimerId, iCutOff);

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMGenericTimer::RunL - return" ) );

    }

void CHWRMGenericTimer::SetMaximumTime(TTimeIntervalMicroSeconds32& aMaximumTime)

	{

	iMaximumTime = aMaximumTime;

	}

//  End of File