/*
* Copyright (c) 2005-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:
* Name          : TimerManager.h
* Part of       : LightWeightTimer
* This header file is included by the subsystem which is 
* responsible for creating the CTimerManager instance.
* Version       : SIP/4.0
*
*/




/**
 @internalComponent
*/

#ifndef TIMERMANAGER_H
#define TIMERMANAGER_H

// INCLUDES
#include <e32base.h>
#include "Lwtimer.h"
#include "mtimernotifier.h"

// FORWARD DECLARATIONS
class CTimerStore;
class CSingleTimer;

// CLASS DECLARATION

/**
 * CTimerManager is the main class of the Lightweight timer subsystem. It is
 * intended to be used in a way that there is only one instance of the
 * CTimerManager class, and the basic timer services are available through the
 * MTimerManager interface.
 *
 * Several logical timers can run simultaneously, but only one RTimer is used.
 */
class CTimerManager :
    public CBase,
	public MTimerNotifier,
	public MTimerManager
	{
public: // Constructors and destructor

	/**
	 * Creates an instance of CTimerManager.
	 *
	 * @see CTimerManager::NewLC
	 *	
	 * @return value The new CTimerManager object. Ownership is transferred.
	 */
	static CTimerManager* NewL();

	/**
	 * Creates an instance of CTimerManager and pushes it to CleanupStack.
	 *
	 * @see CTimerManager::NewL
	 *
	 * @return value The new CTimerManager object. Ownership is transferred.
	 */
	static CTimerManager* NewLC();

    /**
     * Destructor
     */
	~CTimerManager();

public: //From MTimerNotifier

	void TimerExpiredL(TTimerId aTimerId);

	TInt LeaveOccurred();

public: //From MTimerManager	

	TTimerId StartL(MExpirationHandler* aObserver,
				    TUint aMilliseconds);

	TTimerId StartL(MExpirationHandler* aObserver,
					TUint aMilliseconds,
					TAny* aTimerParam);

	TInt Stop(TTimerId aTimerId);
	
	TBool IsRunning(TTimerId aTimerId) const;
	
	TInt ExpiresAfter( TTimerId aTimerId, TUint& aExpiresAfterInMillisecs) const;

private: // Constructors

	CTimerManager();

	/**
	 * Second phase constructor.	 
	 */
	void ConstructL();

private: // For internal use

	/**
	 * Generates a new unique TTimerId value.
	 *	 
	 * @return value New TimerId value
	 */
	TTimerId NewTimerId();

	/**
	 * Set a timer running with the duration of the shortest timer.
	 *
	 * @pre iTimer must not be active	 
	 */
	void SetTimerWithShortestValueL();

	/**
	 * Checks if the recently added new timer is shorter than any of the
	 * existing timers. If it is, the currently running CSingleTimer is
	 * canceled and CSingleTimer is started again, now with the duration of
	 * the new timer.
	 *
	 * @param aTimerId TimerId of the new timer
	 * @param aMilliseconds Duration of the new timer, in milliseconds
	 */
	void CheckIsNewTimerShortestL(TTimerId aTimerId, TUint aMilliseconds);

	/**
	 * Set a dummy timer to simulate a longer timer without the need to use
	 * RTimer::At.
	 */
	void SetInternalTimerL() const;

	/**
	 * Calculates a TTime value by adding the specified amount of time
	 * (aMilliseconds) to current time.	 
	 *
	 * @param aMilliseconds Amount of milliseconds from current time	 
	 * @return value TTime
	 */
	TTime MillisecToTTime(TUint aMilliseconds) const;

	/**
	 * Calculates the amount of milliseconds between current time and aTime and
	 * fills the result into aMilliseconds.
	 *
	 * @param aTime time
	 * @param aMilliseconds Amount of milliseconds from current time	 
	 * @return value ETrue If successful
	 *				 EFalse The duration between aTime and current time is too
	 *						large to fit into TUint.
	 */
	TBool TTimeToMillisec(TTime aTime, TUint& aMilliseconds) const;	

private: // Data

	//Contains information of existing timer requests. Owned.
	CTimerStore* iTimerStore;

	//Timer used by all the timer requests. Owned.
	CSingleTimer* iTimer;

	//Counter used to produce unique TimerId values
	TTimerId iTimerIdCounter;

	//ETrue if CTimerManager is calling MExpirationHandler::TimerExpiredL.
	//Otherwise value is EFalse.
	//This flag is needed as user of CTimerManager might set a new timer within
	//MExpirationHandler::TimerExpiredL, and CTimerManager has to recognize such
	//a situation.
	TBool iNowExpiring;

private: // For testing purposes

	void __DbgTestInvariant() const;
	

#ifdef CPPUNIT_TEST	
	friend class CTimerManager_test;
	friend class CTimerStore_test;
	friend class CTimerRequest_test;
	friend class CSingleTimer_test;
#endif
	};

#endif // end of TIMERMANAGER_H

// End of File