/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 "CEpoc32Timer.h"

CEpoc32Timer* CEpoc32Timer::New( const TUint32 aPeriodInMicroseconds, 
                                 const TBool aRepeatingTimer, 
                                 TCallBack& aCallBackFunc )
  {
  CEpoc32Timer* timer = new CEpoc32Timer( aPeriodInMicroseconds, 
                                          aRepeatingTimer, aCallBackFunc);
  if( timer )
    {
    TRAPD( err, timer->ConstructL() );
    if( err != KErrNone )
      {
      delete timer;
      timer = NULL;
      }
    }
  return timer;
  }

CEpoc32Timer::CEpoc32Timer( const TUint32 aPeriodInMicroseconds, 
                            const TBool aRepeatingTimer, 
                            TCallBack& aCallBackFunc ) :
  CTimer( EPriorityLow ), 
  iCallBackFunc( aCallBackFunc ), 
  iTimeOutInMicroseconds( aPeriodInMicroseconds ),
  iTimeLeftInMicroseconds( 0 ),
  iPeriodInMicrosecondsExceedingRangeOfTInt( 0 ),
  iIsRepeating( aRepeatingTimer )
  {
  }
    
CEpoc32Timer::~CEpoc32Timer()
  {
  Cancel();
  }

void CEpoc32Timer::ConstructL()
  {
  CTimer::ConstructL();
  CActiveScheduler::Add(this);
  // at the very beginning, time-left equals to the timeout 
  iTimeLeftInMicroseconds = iTimeOutInMicroseconds;
  // start the timer;
  Start();
  }

void CEpoc32Timer::RunL()
  {
  // TIMER WILL BE CANCELLED IF SYSTEM TIME CHANGES!!!!!!!!!!!!!!!!!!
  // EPOC undocumented feature: If system time was changed, the system will 
  // cancel all active objects. Timer active objects must react to this.  
  const TInt status = iStatus.Int();
  
  if( status == KErrNone )
    {
    if( iPeriodInMicrosecondsExceedingRangeOfTInt == 0 )
      {
      if( iIsRepeating )
        {
        // start the timer again
        iTimeLeftInMicroseconds = iTimeOutInMicroseconds;
        // kick off
        Start();
        }
      iCallBackFunc.CallBack(); // Callback to Kimono
      }
    else
      {
      After( iPeriodInMicrosecondsExceedingRangeOfTInt );
      iPeriodInMicrosecondsExceedingRangeOfTInt = 0;
      }
    }
  else if( status == KErrCancel )
    {
    // Possible causes:
    // 1. Timer was stopped
    // 2. System time was changed
    //
    // If timer was stopped, we can detect it by checking 
    // if iTimeLeftOnStop != 0
    // Otherwise the system time was changed.
    if( iTimeLeftInMicroseconds == 0 )
      {
      // System time changed
      Stop(); // Save the state of timers
      Resume(); // Start timer over as if it was stopped.
      }
    }
  }

TUint32 CEpoc32Timer::MicrosecondsLeftUntilNextTick() const
  {
  TTime timeoutTime;
  TTime currentTime;
  // get the current time
  currentTime.HomeTime();
  // first figure out when the timer is supposed to stop. (end of timer)
  timeoutTime = iResumeTime + TTimeIntervalMicroSeconds( TInt64( (TUint)iTimeLeftInMicroseconds ) );
  // then see how far we are from the to happen. ( this is gonna be the time left value )
  TTimeIntervalMicroSeconds timeDifference =  currentTime.MicroSecondsFrom( timeoutTime );
  // convert it to uint32
  TTimeIntervalMicroSeconds32 timeDiff32 =  I64INT(Abs( timeDifference.Int64() ) );
  // end return
  return timeDiff32.Int();
  }

void CEpoc32Timer::Start()
  {
  if( !IsActive() )
    {
    // timer start-up time.
    iResumeTime.HomeTime();
    // kick off the timer.
    After( iTimeLeftInMicroseconds );
    }
  }

void CEpoc32Timer::Stop()
  {
  iTimeLeftInMicroseconds = MicrosecondsLeftUntilNextTick();
  Cancel();
  }

void CEpoc32Timer::Resume()
  {
  // resume the timer
  Start();
  }

void CEpoc32Timer::After( TUint32 aPeriodInMicroseconds )
  {
  TTimeIntervalMicroSeconds32 interval(0);
  
  if( aPeriodInMicroseconds > (TUint32)KMaxTInt )
    {
    // Set the timer value in 2 phases, because now internal would 
    // have negative time value, and CTimer::After would panic.
    iPeriodInMicrosecondsExceedingRangeOfTInt = 
        aPeriodInMicroseconds - KMaxTInt;
    interval = KMaxTInt;
    }
  else
    {
    // OK. CTimer::After will not panic
    iPeriodInMicrosecondsExceedingRangeOfTInt = 0;
    interval = aPeriodInMicroseconds;
    }  
  CTimer::After( interval );
  }