widget/nsUserIdleService.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:expandtab:shiftwidth=2:tabstop=2:
   3  */
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #ifndef nsUserIdleService_h__
   9 #define nsUserIdleService_h__
  10
  11 #include "nsIUserIdleServiceInternal.h"
  12 #include "nsCOMPtr.h"
  13 #include "nsITimer.h"
  14 #include "nsTArray.h"
  15 #include "nsIObserver.h"
  16 #include "nsIUserIdleService.h"
  17 #include "nsCategoryCache.h"
  18 #include "nsWeakReference.h"
  19 #include "mozilla/TimeStamp.h"
  20
  21 /**
  22  * Class we can use to store an observer with its associated idle time
  23  * requirement and whether or not the observer thinks it's "idle".
  24  */
  25 class IdleListener {
  26  public:
  27   nsCOMPtr<nsIObserver> observer;
  28   uint32_t reqIdleTime;
  29   bool isIdle;
  30
  31   IdleListener(nsIObserver* obs, uint32_t reqIT, bool aIsIdle = false)
  32       : observer(obs), reqIdleTime(reqIT), isIdle(aIsIdle) {}
  33   ~IdleListener() = default;
  34 };
  35
  36 // This one will be declared later.
  37 class nsUserIdleService;
  38
  39 /**
  40  * Class to handle the daily idle timer.
  41  */
  42 class nsUserIdleServiceDaily : public nsIObserver,
  43                                public nsSupportsWeakReference {
  44  public:
  45   NS_DECL_ISUPPORTS
  46   NS_DECL_NSIOBSERVER
  47
  48   explicit nsUserIdleServiceDaily(nsIUserIdleService* aIdleService);
  49
  50   /**
  51    * Initializes the daily idle observer.
  52    * Keep this separated from the constructor, since it could cause pointer
  53    * corruption due to AddRef/Release of "this".
  54    */
  55   void Init();
  56
  57  private:
  58   virtual ~nsUserIdleServiceDaily();
  59
  60   /**
  61    * StageIdleDaily is the interim call made when an idle-daily event is due.
  62    * However we don't want to fire idle-daily until the user is idle for this
  63    * session, so this sets up a short wait for an idle event which triggers
  64    * the actual idle-daily event.
  65    *
  66    * @param aHasBeenLongWait Pass true indicating nsUserIdleServiceDaily is
  67    * having trouble getting the idle-daily event fired. If true StageIdleDaily
  68    * will use a shorter idle wait time before firing idle-daily.
  69    */
  70   void StageIdleDaily(bool aHasBeenLongWait);
  71
  72   /**
  73    * @note This is a normal pointer, part to avoid creating a cycle with the
  74    * idle service, part to avoid potential pointer corruption due to this class
  75    * being instantiated in the constructor of the service itself.
  76    */
  77   nsIUserIdleService* mIdleService;
  78
  79   /**
  80    * Place to hold the timer used by this class to determine when a day has
  81    * passed, after that it will wait for idle time to be detected.
  82    */
  83   nsCOMPtr<nsITimer> mTimer;
  84
  85   /**
  86    * Function that is called back once a day.
  87    */
  88   static void DailyCallback(nsITimer* aTimer, void* aClosure);
  89
  90   /**
  91    * Cache of observers for the "idle-daily" category.
  92    */
  93   nsCategoryCache<nsIObserver> mCategoryObservers;
  94
  95   /**
  96    * Boolean set to true when daily idle notifications should be disabled.
  97    */
  98   bool mShutdownInProgress;
  99
 100   /**
 101    * Next time we expect an idle-daily timer to fire, in case timers aren't
 102    * very reliable on the platform. Value is in PR_Now microsecond units.
 103    */
 104   PRTime mExpectedTriggerTime;
 105
 106   /**
 107    * Tracks which idle daily observer callback we ask for. There are two: a
 108    * regular long idle wait and a shorter wait if we've been waiting to fire
 109    * idle daily for an extended period. Set by StageIdleDaily.
 110    */
 111   int32_t mIdleDailyTriggerWait;
 112 };
 113
 114 class nsUserIdleService : public nsIUserIdleServiceInternal {
 115  public:
 116   NS_DECL_ISUPPORTS
 117   NS_DECL_NSIUSERIDLESERVICE NS_DECL_NSIUSERIDLESERVICEINTERNAL
 118
 119       protected : static already_AddRefed<nsUserIdleService>
 120                   GetInstance();
 121
 122   nsUserIdleService();
 123   virtual ~nsUserIdleService();
 124
 125   /**
 126    * If there is a platform specific function to poll the system idel time
 127    * then that must be returned in this function, and the function MUST return
 128    * true, otherwise then the function should be left unimplemented or made
 129    * to return false (this can also be used for systems where it depends on
 130    * the configuration of the system if the idle time can be determined)
 131    *
 132    * @param aIdleTime
 133    *        The idle time in ms.
 134    *
 135    * @return true if the idle time could be polled, false otherwise.
 136    *
 137    * @note The time returned by this function can be different than the one
 138    *       returned by GetIdleTime, as that is corrected by any calls to
 139    *       ResetIdleTimeOut(), unless you overwrite that function too...
 140    */
 141   virtual bool PollIdleTime(uint32_t* aIdleTime);
 142
 143  private:
 144   /**
 145    * Ensure that the timer is expiring at least at the given time
 146    *
 147    * The function might not restart the timer if there is one running currently
 148    *
 149    * @param aNextTimeout
 150    *        The last absolute time the timer should expire
 151    */
 152   void SetTimerExpiryIfBefore(mozilla::TimeStamp aNextTimeout);
 153
 154   /**
 155    * Stores the next timeout time, 0 means timer not running
 156    */
 157   mozilla::TimeStamp mCurrentlySetToTimeoutAt;
 158
 159   /**
 160    * mTimer holds the internal timer used by this class to detect when to poll
 161    * for idle time, when to check if idle timers should expire etc.
 162    */
 163   nsCOMPtr<nsITimer> mTimer;
 164
 165   /**
 166    * Array of listeners that wants to be notified about idle time.
 167    */
 168   nsTArray<IdleListener> mArrayListeners;
 169
 170   /**
 171    * Object keeping track of the daily idle thingy.
 172    */
 173   RefPtr<nsUserIdleServiceDaily> mDailyIdle;
 174
 175   /**
 176    * Number of observers currently in idle mode.
 177    */
 178   uint32_t mIdleObserverCount;
 179
 180   /**
 181    * Delta time from last non idle time to when the next observer should switch
 182    * to idle mode
 183    *
 184    * Time in seconds
 185    *
 186    * If this value is 0 it means there are no active observers
 187    */
 188   uint32_t mDeltaToNextIdleSwitchInS;
 189
 190   /**
 191    * If true, the idle service is temporarily disabled, and all idle events
 192    * will be ignored.
 193    */
 194   bool mDisabled = false;
 195
 196   /**
 197    * Absolute value for when the last user interaction took place.
 198    */
 199   mozilla::TimeStamp mLastUserInteraction;
 200
 201   /**
 202    * Function that ensures the timer is running with at least the minimum time
 203    * needed.  It will kill the timer if there are no active observers.
 204    */
 205   void ReconfigureTimer(void);
 206
 207   /**
 208    * Callback function that is called when the internal timer expires.
 209    *
 210    * This in turn calls the IdleTimerCallback that does the real processing
 211    */
 212   static void StaticIdleTimerCallback(nsITimer* aTimer, void* aClosure);
 213
 214   /**
 215    * Function that handles when a timer has expired
 216    */
 217   void IdleTimerCallback(void);
 218 };
 219
 220 #endif  // nsUserIdleService_h__