/*
* Copyright (c) 2006, 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:  Implementation of Timer class 
*
*/



#include "lbtstrategytimer.h"
#include "lbtlogger.h"


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

// -----------------------------------------------------------------------------
// CLbtStrategyTimer::NewL
// 
// -----------------------------------------------------------------------------
//
CLbtStrategyTimer* CLbtStrategyTimer::NewL()
    {
    CLbtStrategyTimer* timer = new ( ELeave ) CLbtStrategyTimer;
    CleanupStack::PushL( timer );
    timer->ConstructL();
    CleanupStack::Pop();
    return timer;
    }

    
// -----------------------------------------------------------------------------
// CLbtStrategyTimer::~CLbtStrategyTimer
// 
// -----------------------------------------------------------------------------
//
CLbtStrategyTimer::~CLbtStrategyTimer()
    {
    FUNC_ENTER("CLbtStrategyTimer::~CLbtStrategyTimer");
    iTimer.Close();
    if( iUtilizeMovementDetection )
    	{
    	if( iMovtDetector )
			{
			iMovtDetector->StopNotification();
			}
    	}    	
    delete iMovtDetector;
    }

    
// -----------------------------------------------------------------------------
// CLbtStrategyTimer::Set
// 
// -----------------------------------------------------------------------------
//    
void CLbtStrategyTimer::Set( TRequestStatus& aStatus, 
                             TTimeIntervalSeconds aSleepInterval,
                             TBool aUtilizeMovementDetection )
    {
    FUNC_ENTER("CLbtStrategyTimer::Set");
    LOG1("Sleeping for interval : %d", aSleepInterval.Int() );
    // Initialize sleeptime with respect to current time. 
    iSleepTime = aSleepInterval;
    
    iUtilizeMovementDetection = aUtilizeMovementDetection;
    
    // Update start time of sleep
    iStartTime.UniversalTime();
    iInterrupt = EFalse;
    
    aStatus = KRequestPending;    
    
    iMovtDetectorNotified = EFalse;
    //Initiate Movt Detector
    if( iMovtDetector && iUtilizeMovementDetection )
        {
        TRAPD( err, iMovtDetector->RequestNotificationL( this , iSleepTime.Int() ) );
        if( KErrNone == err )
            {
            iStatusPtr = &aStatus;
            return;
            }
        else
            {
            delete iMovtDetector;
            iMovtDetector = NULL;
            }
        }
   	iTimerInitialized = ETrue;
    iTimer.AtUTC( aStatus, ( iStartTime + iSleepTime ) );
    }

    
// -----------------------------------------------------------------------------
// CLbtStrategyTimer::ResetInterval
// 
// -----------------------------------------------------------------------------
//  
void CLbtStrategyTimer::ResetInterval( TRequestStatus& aStatus,
                                       TTimeIntervalSeconds aSleepInterval,
                                       TBool aUtilizeMovementDetection )
	{
	FUNC_ENTER("CLbtStrategyTimer::ResetInterval");
	LOG1("ResetInterval;=%d", aSleepInterval.Int());
	if( !iMovtDetectorNotified )
		{
		Set( aStatus, aSleepInterval,aUtilizeMovementDetection );
		return;
		}
	iUtilizeMovementDetection = aUtilizeMovementDetection;
		
	TTime sleepTime;
    sleepTime.UniversalTime();
    sleepTime += aSleepInterval;
    
    iTimer.AtUTC( aStatus, sleepTime );
	iSleepTime = aSleepInterval;
	iStartTime.UniversalTime();
    iInterrupt = EFalse;    
	}

    
// -----------------------------------------------------------------------------
// CLbtStrategyTimer::Cancel
// 
// -----------------------------------------------------------------------------
//
void CLbtStrategyTimer::Cancel()
    {
    FUNC_ENTER("CLbtStrategyTimer::Cancel");
    if( iTimerInitialized )
        {
        iTimer.Cancel();
        }
    if( iMovtDetector && iUtilizeMovementDetection )
        {
        iMovtDetector->StopNotification();
        }
    if(iStatusPtr != NULL)
    	{
    	User::RequestComplete(iStatusPtr, KErrCancel);
    	}
    //  iMovtDetectorNotified = EFalse;
    iInterrupt = ETrue;
    }
    
  
// -----------------------------------------------------------------------------
// CLbtStrategyTimer::RemainingSleepInterval
// 
// -----------------------------------------------------------------------------
//    
TBool CLbtStrategyTimer::RemainingSleepInterval( 
                                    TTimeIntervalSeconds& aRemainingInterval )
    {
    return RemainingSleepInterval( iSleepTime, aRemainingInterval );
    }


// -----------------------------------------------------------------------------
// CLbtStrategyTimer::RemainingSleepInterval
// 
// -----------------------------------------------------------------------------
//    
TBool CLbtStrategyTimer::RemainingSleepInterval( 
                                TTimeIntervalSeconds aEstimatedTime, 
                                TTimeIntervalSeconds& aRemainingInterval )
    {
    TTime currentTime;
	TTimeIntervalSeconds interval;
	currentTime.UniversalTime();
	currentTime.SecondsFrom( iStartTime, interval );
    
    aRemainingInterval = aEstimatedTime.Int() - interval.Int(); 
             
	if( aRemainingInterval.Int() <= 0 )
        {
        return EFalse;
        }
	else
        {
        return ETrue;
        }
    }
 
 
// -----------------------------------------------------------------------------
// CLbtStrategyTimer::SleepIntervalInterrupted
// 
// -----------------------------------------------------------------------------
//    
TBool CLbtStrategyTimer::SleepIntervalInterrupted()
    {
    TBool interrupted = iInterrupt;
    iInterrupt = EFalse;
    return interrupted;
    }


// -----------------------------------------------------------------------------
// CLbtStrategyTimer::ElapsedTime
// 
// -----------------------------------------------------------------------------
//    
CLbtStrategyTimer::CLbtStrategyTimer() : iTimerInitialized( EFalse ), 
										 iMovtDetectorNotified( EFalse ),
										 iMovtDetector( NULL )
    {
    }


// -----------------------------------------------------------------------------
// CLbtStrategyTimer::ElapsedTime
// 
// -----------------------------------------------------------------------------
//    
void CLbtStrategyTimer::ConstructL()
    {
    iInterrupt = EFalse;
    User::LeaveIfError( iTimer.CreateLocal() );
    iMovtDetector = CLbtMovementDetector::NewL();
    iUtilizeMovementDetection = ETrue;
    iStatusPtr = NULL;
    }


// -----------------------------------------------------------------------------
// CLbtStrategyEngine::HandleDetectorNotification
// Handles Movt detection notification
// -----------------------------------------------------------------------------
//
void CLbtStrategyTimer::HandleDetectorNotification( const TMovementObserverEvent /*aEvent*/ )
	{
	FUNC_ENTER("CLbtStrategyTimer::HandleDetectorNotification");
	LOG("Movement detected");
	 // aEvent need not be checked as the handling will remain the same  
	iMovtDetector->StopNotification();
	iMovtDetectorNotified = ETrue;
	
	TTime currentTime;
  	currentTime.UniversalTime();
    
  	if( currentTime > ( iStartTime + iSleepTime ) )
   		{
   		//Notification  after the completion of sleepinterval => Notify the engine immediately
   		User::RequestComplete( iStatusPtr, KErrNone ); 
   		iStatusPtr = NULL;
   		}
  	else
   		{
   		//Notification before the completion of sleepinterval => Notify the engine after the completion 
 		//of sleep interval
		iTimerInitialized = ETrue;
		iTimer.AtUTC( *iStatusPtr, ( iStartTime + iSleepTime ) );
		iStatusPtr = NULL;
   		}
   	}