diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kernel/eka/euser/cbase/ub_tim.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/kernelhwsrv/kernel/eka/euser/cbase/ub_tim.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,539 @@ +// Copyright (c) 1995-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: +// e32\euser\cbase\ub_tim.cpp +// +// + +#include "ub_std.h" + +EXPORT_C CTimer::CTimer(TInt aPriority) + : CActive(aPriority) +/** +Protected constructor with priority. + +Use this constructor to set the priority of the active object. + +Classes derived from CTimer must define and provide a constructor through +which the priority of the active object can be passed. Such a constructor +can call CTimer's constructor in its constructor initialisation list. + +@param aPriority The priority of the timer. +*/ + { + } + + + + +EXPORT_C CTimer::~CTimer() +/** +Destructor. + +Frees resources prior to destruction. Specifically, it cancels any outstanding +request and closes the RTimer handle. +*/ + { + + Cancel(); + iTimer.Close(); + } + + + + +EXPORT_C void CTimer::At(const TTime &aTime) +/** +Requests an event at a given local time. + +This timer completes at the specified time - if the machine is in a +turned off state at that time, the machine will be turned on again. + +Notes: + +1. The CTimer' RunL() function will be run as soon as possible after the + specified system time. + +2. The RunL() may be delayed because the RunL() of another active object, with + the deepest nesting-level active scheduler on the same thread, is running + when the event occurs: this cannot be avoided, but can be minimised by + making all RunL()s of short duration. + +3. The RunL() may be delayed because other, higher-priority, active objects are + scheduled instead. This can be avoided by making CTimers very high-priority. + +4. The TTime object should be set to the home time. + +@param aTime The local time at which the event is to occur. + +@see TTime::HomeTime +*/ + { + + __ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded)); + iTimer.At(iStatus,aTime); + SetActive(); + } + + + + +EXPORT_C void CTimer::AtUTC(const TTime &aTimeInUTC) +/** +Requests an event at a given UTC time. + +This timer completes at the specified time - if the machine is in a +turned off state at that time, the machine will be turned on again. + +Notes: + +1. The CTimer' RunL() function will be run as soon as possible after the + specified system time. + +2. The RunL() may be delayed because the RunL() of another active object, with + the deepest nesting-level active scheduler on the same thread, is running + when the event occurs: this cannot be avoided, but can be minimised by + making all RunL()s of short duration. + +3. The RunL() may be delayed because other, higher-priority, active objects are + scheduled instead. This can be avoided by making CTimers very high-priority. + +4. The TTime object should be set to the universal time. + +@param aTime The UTC time at which the event is to occur. + +@see TTime::UniversalTime +*/ + { + + __ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded)); + iTimer.AtUTC(iStatus,aTimeInUTC); + SetActive(); + } + + + + +EXPORT_C void CTimer::After(TTimeIntervalMicroSeconds32 anInterval) +/** +Requests an event after an interval. + +This timer completes after the specified number of microseconds. The +"after timer" counter stops during power-down. Therefore, a 5-second timer +will complete late if the machine is turned off 2 seconds after the request +is made. + +Notes: + +1. The CTimer's RunL() function will be run as soon as possible after the + specified interval. + +2. The RunL() may be delayed because the RunL() of another active object, with + the deepest nesting-level active scheduler on the same thread, is running + when the event occurs: this cannot be avoided, but can be minimised by + making all RunL()s of short duration. + +3. The RunL() may be delayed because other, higher-priority, active objects are + scheduled instead. This can be avoided by making CTimers very high-priority. + +@param anInterval Interval after which event is to occur, in microseconds. + +@panic USER 87, if anInterval is negative. This is raised by the + underlying RTimer. +@panic E32USER-CBase 51, if the active object has not been added to an + active scheduler. + +@see RTimer +*/ + { + + __ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded)); + iTimer.After(iStatus,anInterval); + SetActive(); + } + + + + +EXPORT_C void CTimer::Lock(TTimerLockSpec aLock) +/** +Requests an event on a specified second fraction. + +Note that the RunL() function is run exactly on the specified second fraction. + +@param aLock The fraction of a second at which the timer completes. +*/ + { + + __ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded)); + iTimer.Lock(iStatus,aLock); + SetActive(); + } + + + + +EXPORT_C void CTimer::Inactivity(TTimeIntervalSeconds aSeconds) +/** +Requests an event if no activity occurs within the specified interval. + +@param aSeconds The time interval. +*/ + { + + __ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded)); + iTimer.Inactivity(iStatus, aSeconds); + SetActive(); + } + + + +EXPORT_C void CTimer::HighRes(TTimeIntervalMicroSeconds32 aInterval) +/** +Requests an event after the specified interval to a resolution of 1ms. +The "HighRes timer" counter stops during power-down (the same as "after timer"). + +@param aInterval The time interval, in microseconds, after which an event + is to occur. +@panic USER 87, if anInterval is negative. This is raised by the + underlying RTimer. +@panic KERN-EXEC 15, if this function is called while a request for a timer + event is still outstanding. +*/ + { + + __ASSERT_ALWAYS(IsAdded(),Panic(ETimNotAdded)); + iTimer.HighRes(iStatus, aInterval); + SetActive(); + } + + + + +EXPORT_C void CTimer::ConstructL() +/** +Constructs a new asynchronous timer. + +The function must be called before any timer requests (i.e. calls to +RTimer::After() or RTimer::At()) can be made. + +Since it is protected, it cannot be called directly by clients of CTimer +derived classes. Typically, a derived class makes a base call to this function +in the second phase of two-phase construction; i.e. the derived class defines +and implements its own ConstructL() function within which it makes a base +call to CTimer::ConstructL(). +*/ + { + + TInt r=iTimer.CreateLocal(); + if (r!=KErrNone) + User::Leave(r); + } + + + + +EXPORT_C void CTimer::DoCancel() +// +// Cancel the timer. +// + { + + iTimer.Cancel(); + } + + + + +EXPORT_C CPeriodic *CPeriodic::New(TInt aPriority) +/** +Allocates and constructs a CPeriodic object - non-leaving. + +Specify a high priority so the callback function is scheduled as soon as +possible after the timer events complete. + +@param aPriority The priority of the active object. If timing is critical, + it should be higher than that of all other active objects + owned by the scheduler. + +@return Pointer to new CPeriodic object. The object is initialised and added + to the active scheduler. This value is NULL if there is insufficient + memory. +*/ + { + + CPeriodic *pP=new CPeriodic(aPriority); + if (pP) + { + TRAPD(r,pP->ConstructL()); + if (r==KErrNone) + CActiveScheduler::Add(pP); + else + { + delete pP; + pP=NULL; + } + } + return pP; + } + + + + +EXPORT_C CPeriodic *CPeriodic::NewL(TInt aPriority) +/** +Allocates and constructs a CPeriodic object - leaving. + +Specify a high priority so the callback function is scheduled as soon as +possible after the timer events complete. + +@param aPriority The priority of the active object. If timing is critical, + it should be higher than that of all other active objects + owned by the scheduler. + +@return Pointer to new CPeriodic object. The object is initialised and added + to the active scheduler. + +@leave KErrNoMemory There is insufficient memory to create the object. +*/ + { + + return((CPeriodic *)User::LeaveIfNull(New(aPriority))); + } + + + + +EXPORT_C CPeriodic::CPeriodic(TInt aPriority) + : CTimer(aPriority) +/** +Protected constructor with priority. + +Use this constructor to set the priority of the active object. + +Classes derived from CPeriodic must define and provide a constructor through +which the priority of the active object can be passed. Such a constructor +can call CPeriodic's constructor in its constructor initialisation list. + +@param aPriority The priority of the timer. +*/ + { + } + + + + +EXPORT_C CPeriodic::~CPeriodic() +/** +Destructor. + +Frees resources prior to destruction. +*/ + { + } + + + + +EXPORT_C void CPeriodic::Start(TTimeIntervalMicroSeconds32 aDelay,TTimeIntervalMicroSeconds32 anInterval,TCallBack aCallBack) +/** +Starts generating periodic events. + +The event calls the protected RunL() function, +which in turn calls the function specified by aCallBack. The first event is +generated after aDelay microseconds; subsequent events are generated regularly +thereafter at intervals of anInterval microseconds. + +The TCallBack contains a function pointer and a TAny* pointer. The function +will be repeatedly called with the pointer as a parameter. + +Once started, periodic events are generated until the CPeriodic object is +destroyed. + +Notes: + +1. The callback function will be run as soon as possible after the initial delay, + and after each period. + +2. The callback may be delayed because the RunL() of another active object, with + the deepest nesting-level active scheduler on the same thread, is running + when the event occurs: this cannot be avoided, but can be minimised by making + all RunL()s of short duration. + +3. The callback may be delayed because other, higher-priority, active objects + are scheduled instead. This can be avoided by giving the CPeriodic a very + high priority. + +@param aDelay The delay from the Start() function to the generation of the + first event, in microseconds. +@param anInterval The interval between events generated after the initial + delay, in microseconds. +@param aCallBack A callback specifying a function to be called when the CPeriodic + is scheduled after a timer event. + +@panic E32USER-CBase 52, if anInterval is negative. +@panic E32USER-CBase 53, if aDelay is negative. +*/ + { + + __ASSERT_ALWAYS(anInterval.Int()>=0,Panic(ETimIntervalNegativeOrZero)); + __ASSERT_ALWAYS(aDelay.Int()>=0,Panic(ETimDelayNegative)); + iInterval=anInterval.Int(); + iCallBack=aCallBack; + After(aDelay); + } + +EXPORT_C void CPeriodic::RunL() +// +// Handle completion by issuing the next request and then calling back. +// + { + + After(iInterval); + iCallBack.CallBack(); + } + + + + +EXPORT_C CHeartbeat::CHeartbeat(TInt aPriority) + : CTimer(aPriority) +/** +Protected constructor with a priority. Use this constructor to set the priority +of the active object. + +Classes derived from CHeartbeat must define and provide a constructor through +which the priority of the active object can be passed. Such a constructor +can call CHeartbeat's constructor in its constructor initialisation list. + +@param aPriority The priority of the timer. +*/ + {} + + + + +EXPORT_C CHeartbeat *CHeartbeat::New(TInt aPriority) +/** +Allocates and constructs a CHeartbeat object - non-leaving. + +Specify a high priority so the callback function is scheduled as soon as +possible after the timer events complete. + +@param aPriority The priority of the active object. If timing is critical, + it should be higher than that of all other active objects + owned by the scheduler. + +@return Pointer to new CHeartbeat object. The object is initialised and added + to the active scheduler. This value is NULL if insufficient memory was + available. +*/ + { + + CHeartbeat *pP=new CHeartbeat(aPriority); + if (pP) + { + TRAPD(r,pP->ConstructL()); + if (r==KErrNone) + CActiveScheduler::Add(pP); + else + { + delete pP; + pP=NULL; + } + } + return pP; + } + + + + +EXPORT_C CHeartbeat *CHeartbeat::NewL(TInt aPriority) +/** +Allocates and constructs a CHeartbeat object - leaving. + +Specify a high priority so the callback function is scheduled as soon as +possible after the timer events complete. + +@param aPriority The priority of the active object. If timing is critical, + it should be higher than that of all other active objects + owned by the scheduler. + +@return Pointer to new CHeartbeat object. The object is initialised and added + to the active scheduler. +*/ + { + + return((CHeartbeat *)User::LeaveIfNull(New(aPriority))); + } + + + + +EXPORT_C CHeartbeat::~CHeartbeat() +/** +Destructor. + +Frees resources prior to destruction. +*/ + {} + + + + +EXPORT_C void CHeartbeat::Start(TTimerLockSpec aLock, MBeating *aBeating) +/** +Starts generating heartbeat events. The event results in calls to the Beat() +and Synchronize() functions specified by aBeating. + +The first event is generated on the first fraction of a second corresponding +to aLock that occurs after Start() has returned; subsequent events are generated +regularly thereafter at one second intervals on the second fraction specified +by aLock. + +The aBeating mixin must be written by the user. Most of the time, its Beat() +function is called which trivially updates the tick count. Occasionally, synchronisation +is lost, and the Synchronize() function is called instead: this must find +out from the system time how many ticks should have been counted, and update +things accordingly. + +Once started, heartbeat events are generated until the CHeartbeat object is +destroyed. + +@param aLock The fraction of a second at which the timer completes. +@param aBeating Provides the Beat() and Synchronize() functions. +*/ + { + + iBeating=aBeating; + iLock=aLock; + Lock(aLock); + } + + + + +EXPORT_C void CHeartbeat::RunL() +// +// Handle completion +// + { + + TRequestStatus stat=iStatus; + Lock(iLock); + if (stat==KErrNone) + iBeating->Beat(); + else + iBeating->Synchronize(); + } +