/*
* Copyright (c) 2007 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:  Haptics generic timer class definition.
*
*/


#include <e32base.h>
#include "hwrmhapticsgenerictimer.h"
#include "hwrmhapticstrace.h"

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

// -----------------------------------------------------------------------------
// CHWRMHapticsGenericTimer::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CHWRMHapticsGenericTimer* CHWRMHapticsGenericTimer::NewL(
        MHWRMHapticsGenericTimerCallback* aCallback,
        const TTimeIntervalMicroSeconds32& aMaxTime,
        TInt aTimerId )
    {
    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::NewL(0x%x, 0x%x, 0x%x)" ), aCallback, aMaxTime.Int(), aTimerId ) );

    CHWRMHapticsGenericTimer* self = new ( ELeave ) CHWRMHapticsGenericTimer(
                                                                aCallback,
                                                                aMaxTime,
                                                                aTimerId );
    CleanupStack::PushL( self );
    self->ConstructL();   //base call
    CleanupStack::Pop( self );

    CActiveScheduler::Add( self );

    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::NewL - return 0x%x" ), self ) );
    return self;
    }

// -----------------------------------------------------------------------------
// CHWRMHapticsGenericTimer::CHWRMHapticsGenericTimer
// Constructor with callback class as a parameter.
// -----------------------------------------------------------------------------
//
CHWRMHapticsGenericTimer::CHWRMHapticsGenericTimer(
        MHWRMHapticsGenericTimerCallback* aCallback, 
        const TTimeIntervalMicroSeconds32& aMaxTime,
        TInt aTimerId )
        : CTimer( EPriorityHigh ), 
          iCallback( aCallback ),
          iMaximumTime( aMaxTime ),
          iCutOff( EFalse ),
          iTimerId( aTimerId )
    {
    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::CHWRMHapticsGenericTimer(0x%x, 0x%x)" ), aCallback, aMaxTime.Int() ) );

    __ASSERT_ALWAYS( aCallback, User::Invariant() );

    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::CHWRMHapticsGenericTimer - return" ) ) );
    }

// -----------------------------------------------------------------------------
// CHWRMHapticsGenericTimer::~CHWRMHapticsGenericTimer
// Destructor.
// -----------------------------------------------------------------------------
//
CHWRMHapticsGenericTimer::~CHWRMHapticsGenericTimer()
    {
    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::~CHWRMHapticsGenericTimer()" ) ) );
    
    iCallback = NULL;
    
    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::~CHWRMHapticsGenericTimer - return" ) ) );
    }

// -----------------------------------------------------------------------------
// CHWRMHapticsGenericTimer::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 CHWRMHapticsGenericTimer::Set(const TTimeIntervalMicroSeconds32& aInterval)
    {
    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::Set(%d)" ), aInterval.Int() ) );

    __ASSERT_ALWAYS( CActiveScheduler::Current(), User::Invariant() );

    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_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::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_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::Set - return" ) ) );
    }

// -----------------------------------------------------------------------------
// CHWRMHapticsGenericTimer::Freeze
// Stop timer and returns the remaining time
// -----------------------------------------------------------------------------
//
TTimeIntervalMicroSeconds32 CHWRMHapticsGenericTimer::Freeze()
    {
    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::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_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::Freeze - return %d" ), frozenTime.Int64() ) );    

    // Loss of precision ok, as frozentime never exceeds 32 bits.    
    return frozenTime.Int64();
    }

// -----------------------------------------------------------------------------
// CHWRMHapticsGenericTimer::RunL
// RunL() function will be run after the specified system time expires,
// i.e. time is set by After() method,
// -----------------------------------------------------------------------------
void CHWRMHapticsGenericTimer::RunL()
    {
    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::RunL()" ) ) );

    __ASSERT_ALWAYS( iCallback, User::Invariant() );
    
    iCallback->GenericTimerFired( iTimerId, iCutOff );
    
    COMPONENT_TRACE( ( _L( "HWRMHaptics Server - CHWRMHapticsGenericTimer::RunL - return" ) ) );
    }

//  End of File