diff options
Diffstat (limited to 'widget/nsUserIdleService.cpp')
| -rw-r--r-- | widget/nsUserIdleService.cpp | 900 |
1 files changed, 900 insertions, 0 deletions
diff --git a/widget/nsUserIdleService.cpp b/widget/nsUserIdleService.cpp new file mode 100644 index 0000000000..f70a4bb459 --- /dev/null +++ b/widget/nsUserIdleService.cpp @@ -0,0 +1,900 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:expandtab:shiftwidth=2:tabstop=2: + */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsError.h" +#include "nsIAsyncShutdown.h" +#include "nsUserIdleService.h" +#include "nsString.h" +#include "nsIObserverService.h" +#include "nsDebug.h" +#include "nsCOMArray.h" +#include "nsXULAppAPI.h" +#include "prinrval.h" +#include "mozilla/Logging.h" +#include "prtime.h" +#include "mozilla/AppShutdown.h" +#include "mozilla/dom/ContentChild.h" +#include "mozilla/Services.h" +#include "mozilla/Preferences.h" +#include "mozilla/Telemetry.h" +#include <algorithm> + +#ifdef MOZ_WIDGET_ANDROID +# include <android/log.h> +#endif + +using namespace mozilla; + +// After the twenty four hour period expires for an idle daily, this is the +// amount of idle time we wait for before actually firing the idle-daily +// event. +#define DAILY_SIGNIFICANT_IDLE_SERVICE_SEC (3 * 60) + +// In cases where it's been longer than twenty four hours since the last +// idle-daily, this is the shortend amount of idle time we wait for before +// firing the idle-daily event. +#define DAILY_SHORTENED_IDLE_SERVICE_SEC 60 + +// Pref for last time (seconds since epoch) daily notification was sent. +#define PREF_LAST_DAILY "idle.lastDailyNotification" + +// Number of seconds in a day. +#define SECONDS_PER_DAY 86400 + +static LazyLogModule sLog("idleService"); + +#define LOG_TAG "GeckoIdleService" +#define LOG_LEVEL ANDROID_LOG_DEBUG + +// Use this to find previously added observers in our array: +class IdleListenerComparator { + public: + bool Equals(IdleListener a, IdleListener b) const { + return (a.observer == b.observer) && (a.reqIdleTime == b.reqIdleTime); + } +}; + +//////////////////////////////////////////////////////////////////////////////// +//// nsUserIdleServiceDaily + +NS_IMPL_ISUPPORTS(nsUserIdleServiceDaily, nsIObserver, nsISupportsWeakReference) + +NS_IMETHODIMP +nsUserIdleServiceDaily::Observe(nsISupports*, const char* aTopic, + const char16_t*) { + auto shutdownInProgress = + AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed); + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: Observe '%s' (%d)", aTopic, + shutdownInProgress)); + + if (shutdownInProgress || strcmp(aTopic, OBSERVER_TOPIC_ACTIVE) == 0) { + return NS_OK; + } + MOZ_ASSERT(strcmp(aTopic, OBSERVER_TOPIC_IDLE) == 0); + + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: Notifying idle-daily observers")); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, "Notifying idle-daily observers"); +#endif + + // Send the idle-daily observer event + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + NS_ENSURE_STATE(observerService); + (void)observerService->NotifyObservers(nullptr, OBSERVER_TOPIC_IDLE_DAILY, + nullptr); + + // Notify the category observers. + nsCOMArray<nsIObserver> entries; + mCategoryObservers.GetEntries(entries); + for (int32_t i = 0; i < entries.Count(); ++i) { + (void)entries[i]->Observe(nullptr, OBSERVER_TOPIC_IDLE_DAILY, nullptr); + } + + // Stop observing idle for today. + (void)mIdleService->RemoveIdleObserver(this, mIdleDailyTriggerWait); + + // Set the last idle-daily time pref. + int32_t nowSec = static_cast<int32_t>(PR_Now() / PR_USEC_PER_SEC); + Preferences::SetInt(PREF_LAST_DAILY, nowSec); + + // Force that to be stored so we don't retrigger twice a day under + // any circumstances. + nsIPrefService* prefs = Preferences::GetService(); + if (prefs) { + prefs->SavePrefFile(nullptr); + } + + MOZ_LOG( + sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: Storing last idle time as %d sec.", nowSec)); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, "Storing last idle time as %d", + nowSec); +#endif + + // Note the moment we expect to get the next timer callback + mExpectedTriggerTime = + PR_Now() + ((PRTime)SECONDS_PER_DAY * (PRTime)PR_USEC_PER_SEC); + + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: Restarting daily timer")); + + // Start timer for the next check in one day. + (void)mTimer->InitWithNamedFuncCallback( + DailyCallback, this, SECONDS_PER_DAY * PR_MSEC_PER_SEC, + nsITimer::TYPE_ONE_SHOT, "nsUserIdleServiceDaily::Observe"); + + return NS_OK; +} + +nsUserIdleServiceDaily::nsUserIdleServiceDaily(nsIUserIdleService* aIdleService) + : mIdleService(aIdleService), + mTimer(NS_NewTimer()), + mCategoryObservers(OBSERVER_TOPIC_IDLE_DAILY), + mExpectedTriggerTime(0), + mIdleDailyTriggerWait(DAILY_SIGNIFICANT_IDLE_SERVICE_SEC) {} + +void nsUserIdleServiceDaily::Init() { + // First check the time of the last idle-daily event notification. If it + // has been 24 hours or higher, or if we have never sent an idle-daily, + // get ready to send an idle-daily event. Otherwise set a timer targeted + // at 24 hours past the last idle-daily we sent. + + int32_t lastDaily = Preferences::GetInt(PREF_LAST_DAILY, 0); + // Setting the pref to -1 allows to disable idle-daily, and it's particularly + // useful in tests. Normally there should be no need for the user to set + // this value. + if (lastDaily == -1) { + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: Init: disabled idle-daily")); + return; + } + + int32_t nowSec = static_cast<int32_t>(PR_Now() / PR_USEC_PER_SEC); + if (lastDaily < 0 || lastDaily > nowSec) { + // The time is bogus, use default. + lastDaily = 0; + } + int32_t secondsSinceLastDaily = nowSec - lastDaily; + + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: Init: seconds since last daily: %d", + secondsSinceLastDaily)); + + // If it has been twenty four hours or more or if we have never sent an + // idle-daily event get ready to send it during the next idle period. + if (secondsSinceLastDaily > SECONDS_PER_DAY) { + // Check for a "long wait", e.g. 48-hours or more. + bool hasBeenLongWait = + (lastDaily && (secondsSinceLastDaily > (SECONDS_PER_DAY * 2))); + + MOZ_LOG( + sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: has been long wait? %d", hasBeenLongWait)); + + // StageIdleDaily sets up a wait for the user to become idle and then + // sends the idle-daily event. + StageIdleDaily(hasBeenLongWait); + } else { + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: Setting timer a day from now")); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, "Setting timer a day from now"); +#endif + + // According to our last idle-daily pref, the last idle-daily was fired + // less then 24 hours ago. Set a wait for the amount of time remaining. + int32_t milliSecLeftUntilDaily = + (SECONDS_PER_DAY - secondsSinceLastDaily) * PR_MSEC_PER_SEC; + + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: Seconds till next timeout: %d", + (SECONDS_PER_DAY - secondsSinceLastDaily))); + + // Mark the time at which we expect this to fire. On systems with faulty + // timers, we need to be able to cross check that the timer fired at the + // expected time. + mExpectedTriggerTime = + PR_Now() + (milliSecLeftUntilDaily * PR_USEC_PER_MSEC); + + (void)mTimer->InitWithNamedFuncCallback( + DailyCallback, this, milliSecLeftUntilDaily, nsITimer::TYPE_ONE_SHOT, + "nsUserIdleServiceDaily::Init"); + } +} + +nsUserIdleServiceDaily::~nsUserIdleServiceDaily() { + if (mTimer) { + mTimer->Cancel(); + mTimer = nullptr; + } +} + +void nsUserIdleServiceDaily::StageIdleDaily(bool aHasBeenLongWait) { + NS_ASSERTION(mIdleService, "No idle service available?"); + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: Registering Idle observer callback " + "(short wait requested? %d)", + aHasBeenLongWait)); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, "Registering Idle observer callback"); +#endif + mIdleDailyTriggerWait = + (aHasBeenLongWait ? DAILY_SHORTENED_IDLE_SERVICE_SEC + : DAILY_SIGNIFICANT_IDLE_SERVICE_SEC); + (void)mIdleService->AddIdleObserver(this, mIdleDailyTriggerWait); +} + +// static +void nsUserIdleServiceDaily::DailyCallback(nsITimer* aTimer, void* aClosure) { + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: DailyCallback running")); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, "DailyCallback running"); +#endif + + nsUserIdleServiceDaily* self = static_cast<nsUserIdleServiceDaily*>(aClosure); + + // Check to be sure the timer didn't fire early. This currently only + // happens on android. + PRTime now = PR_Now(); + if (self->mExpectedTriggerTime && now < self->mExpectedTriggerTime) { + // Timer returned early, reschedule to the appropriate time. + PRTime delayTime = self->mExpectedTriggerTime - now; + + // Add 10 ms to ensure we don't undershoot, and never get a "0" timer. + delayTime += 10 * PR_USEC_PER_MSEC; + + MOZ_LOG(sLog, LogLevel::Debug, + ("nsUserIdleServiceDaily: DailyCallback resetting timer to %" PRId64 + " msec", + delayTime / PR_USEC_PER_MSEC)); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "DailyCallback resetting timer to %" PRId64 " msec", + delayTime / PR_USEC_PER_MSEC); +#endif + + (void)self->mTimer->InitWithNamedFuncCallback( + DailyCallback, self, delayTime / PR_USEC_PER_MSEC, + nsITimer::TYPE_ONE_SHOT, "nsUserIdleServiceDaily::DailyCallback"); + return; + } + + // Register for a short term wait for idle event. When this fires we fire + // our idle-daily event. + self->StageIdleDaily(false); +} + +/** + * The idle services goal is to notify subscribers when a certain time has + * passed since the last user interaction with the system. + * + * On some platforms this is defined as the last time user events reached this + * application, on other platforms it is a system wide thing - the preferred + * implementation is to use the system idle time, rather than the application + * idle time, as the things depending on the idle service are likely to use + * significant resources (network, disk, memory, cpu, etc.). + * + * When the idle service needs to use the system wide idle timer, it typically + * needs to poll the idle time value by the means of a timer. It needs to + * poll fast when it is in active idle mode (when it has a listener in the idle + * mode) as it needs to detect if the user is active in other applications. + * + * When the service is waiting for the first listener to become idle, or when + * it is only monitoring application idle time, it only needs to have the timer + * expire at the time the next listener goes idle. + * + * The core state of the service is determined by: + * + * - A list of listeners. + * + * - A boolean that tells if any listeners are in idle mode. + * + * - A delta value that indicates when, measured from the last non-idle time, + * the next listener should switch to idle mode. + * + * - An absolute time of the last time idle mode was detected (this is used to + * judge if we have been out of idle mode since the last invocation of the + * service. + * + * There are four entry points into the system: + * + * - A new listener is registered. + * + * - An existing listener is deregistered. + * + * - User interaction is detected. + * + * - The timer expires. + * + * When a new listener is added its idle timeout, is compared with the next idle + * timeout, and if lower, that time is stored as the new timeout, and the timer + * is reconfigured to ensure a timeout around the time the new listener should + * timeout. + * + * If the next idle time is above the idle time requested by the new listener + * it won't be informed until the timer expires, this is to avoid recursive + * behavior and to simplify the code. In this case the timer will be set to + * about 10 ms. + * + * When an existing listener is deregistered, it is just removed from the list + * of active listeners, we don't stop the timer, we just let it expire. + * + * When user interaction is detected, either because it was directly detected or + * because we polled the system timer and found it to be unexpected low, then we + * check the flag that tells us if any listeners are in idle mode, if there are + * they are removed from idle mode and told so, and we reset our state + * caculating the next timeout and restart the timer if needed. + * + * ---- Build in logic + * + * In order to avoid restarting the timer endlessly, the timer function has + * logic that will only restart the timer, if the requested timeout is before + * the current timeout. + * + */ + +//////////////////////////////////////////////////////////////////////////////// +//// nsUserIdleService + +namespace { +nsUserIdleService* gIdleService; +} // namespace + +already_AddRefed<nsUserIdleService> nsUserIdleService::GetInstance() { + RefPtr<nsUserIdleService> instance(gIdleService); + return instance.forget(); +} + +class UserIdleBlocker final : public nsIAsyncShutdownBlocker { + ~UserIdleBlocker() = default; + + public: + explicit UserIdleBlocker() = default; + + NS_IMETHOD + GetName(nsAString& aNameOut) override { + aNameOut = nsLiteralString(u"UserIdleBlocker"); + return NS_OK; + } + + NS_IMETHOD + BlockShutdown(nsIAsyncShutdownClient* aClient) override { + if (gIdleService) { + gIdleService->SetDisabledForShutdown(); + } + aClient->RemoveBlocker(this); + return NS_OK; + } + + NS_IMETHOD + GetState(nsIPropertyBag**) override { return NS_OK; } + + NS_DECL_ISUPPORTS +}; + +NS_IMPL_ISUPPORTS(UserIdleBlocker, nsIAsyncShutdownBlocker) + +nsUserIdleService::nsUserIdleService() + : mIdleObserverCount(0), + mDeltaToNextIdleSwitchInS(UINT32_MAX), + mLastUserInteraction(TimeStamp::Now()) { + MOZ_ASSERT(!gIdleService); + gIdleService = this; + if (XRE_IsParentProcess()) { + mDailyIdle = new nsUserIdleServiceDaily(this); + mDailyIdle->Init(); + } + nsCOMPtr<nsIAsyncShutdownService> svc = services::GetAsyncShutdownService(); + MOZ_ASSERT(svc); + nsCOMPtr<nsIAsyncShutdownClient> client; + auto rv = svc->GetQuitApplicationGranted(getter_AddRefs(client)); + if (NS_FAILED(rv)) { + // quitApplicationGranted can be undefined in some environments. + rv = svc->GetXpcomWillShutdown(getter_AddRefs(client)); + } + MOZ_ASSERT(NS_SUCCEEDED(rv)); + client->AddBlocker(new UserIdleBlocker(), + NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__, + u""_ns); +} + +nsUserIdleService::~nsUserIdleService() { + if (mTimer) { + mTimer->Cancel(); + } + + MOZ_ASSERT(gIdleService == this); + gIdleService = nullptr; +} + +NS_IMPL_ISUPPORTS(nsUserIdleService, nsIUserIdleService, + nsIUserIdleServiceInternal) + +void nsUserIdleService::SetDisabledForShutdown() { + SetDisabled(true); + if (mTimer) { + mTimer->Cancel(); + mTimer = nullptr; + } +} + +NS_IMETHODIMP +nsUserIdleService::AddIdleObserver(nsIObserver* aObserver, + uint32_t aIdleTimeInS) { + NS_ENSURE_ARG_POINTER(aObserver); + // We don't accept idle time at 0, and we can't handle idle time that are too + // high either - no more than ~136 years. + NS_ENSURE_ARG_RANGE(aIdleTimeInS, 1, (UINT32_MAX / 10) - 1); + + if (profiler_thread_is_being_profiled_for_markers()) { + nsAutoCString timeCStr; + timeCStr.AppendInt(aIdleTimeInS); + PROFILER_MARKER_TEXT("UserIdle::AddObserver", OTHER, MarkerStack::Capture(), + timeCStr); + } + + if (XRE_IsContentProcess()) { + dom::ContentChild* cpc = dom::ContentChild::GetSingleton(); + cpc->AddIdleObserver(aObserver, aIdleTimeInS); + return NS_OK; + } + + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: Register idle observer %p for %d seconds", aObserver, + aIdleTimeInS)); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "Register idle observer %p for %d seconds", aObserver, + aIdleTimeInS); +#endif + + // Put the time + observer in a struct we can keep: + IdleListener listener(aObserver, aIdleTimeInS); + + // XXX(Bug 1631371) Check if this should use a fallible operation as it + // pretended earlier. + mArrayListeners.AppendElement(listener); + + // Create our timer callback if it's not there already. + if (!mTimer) { + mTimer = NS_NewTimer(); + NS_ENSURE_TRUE(mTimer, NS_ERROR_OUT_OF_MEMORY); + } + + // Check if the newly added observer has a smaller wait time than what we + // are waiting for now. + if (mDeltaToNextIdleSwitchInS > aIdleTimeInS) { + // If it is, then this is the next to move to idle (at this point we + // don't care if it should have switched already). + MOZ_LOG( + sLog, LogLevel::Debug, + ("idleService: Register: adjusting next switch from %d to %d seconds", + mDeltaToNextIdleSwitchInS, aIdleTimeInS)); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "Register: adjusting next switch from %d to %d seconds", + mDeltaToNextIdleSwitchInS, aIdleTimeInS); +#endif + + mDeltaToNextIdleSwitchInS = aIdleTimeInS; + ReconfigureTimer(); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsUserIdleService::RemoveIdleObserver(nsIObserver* aObserver, + uint32_t aTimeInS) { + NS_ENSURE_ARG_POINTER(aObserver); + NS_ENSURE_ARG(aTimeInS); + + if (profiler_thread_is_being_profiled_for_markers()) { + nsAutoCString timeCStr; + timeCStr.AppendInt(aTimeInS); + PROFILER_MARKER_TEXT("UserIdle::RemoveObserver", OTHER, + MarkerStack::Capture(), timeCStr); + } + + if (XRE_IsContentProcess()) { + dom::ContentChild* cpc = dom::ContentChild::GetSingleton(); + cpc->RemoveIdleObserver(aObserver, aTimeInS); + return NS_OK; + } + + IdleListener listener(aObserver, aTimeInS); + + // Find the entry and remove it, if it was the last entry, we just let the + // existing timer run to completion (there might be a new registration in a + // little while. + IdleListenerComparator c; + nsTArray<IdleListener>::index_type listenerIndex = + mArrayListeners.IndexOf(listener, 0, c); + if (listenerIndex != mArrayListeners.NoIndex) { + if (mArrayListeners.ElementAt(listenerIndex).isIdle) mIdleObserverCount--; + mArrayListeners.RemoveElementAt(listenerIndex); + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: Remove observer %p (%d seconds), %d remain idle", + aObserver, aTimeInS, mIdleObserverCount)); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "Remove observer %p (%d seconds), %d remain idle", + aObserver, aTimeInS, mIdleObserverCount); +#endif + return NS_OK; + } + + // If we get here, we haven't removed anything: + MOZ_LOG(sLog, LogLevel::Warning, + ("idleService: Failed to remove idle observer %p (%d seconds)", + aObserver, aTimeInS)); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "Failed to remove idle observer %p (%d seconds)", + aObserver, aTimeInS); +#endif + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsUserIdleService::ResetIdleTimeOut(uint32_t idleDeltaInMS) { + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: Reset idle timeout (last interaction %u msec)", + idleDeltaInMS)); + + // Store the time + mLastUserInteraction = + TimeStamp::Now() - TimeDuration::FromMilliseconds(idleDeltaInMS); + + // If no one is idle, then we are done, any existing timers can keep running. + if (mIdleObserverCount == 0) { + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: Reset idle timeout: no idle observers")); + return NS_OK; + } + + // Mark all idle services as non-idle, and calculate the next idle timeout. + nsCOMArray<nsIObserver> notifyList; + mDeltaToNextIdleSwitchInS = UINT32_MAX; + + // Loop through all listeners, and find any that have detected idle. + for (uint32_t i = 0; i < mArrayListeners.Length(); i++) { + IdleListener& curListener = mArrayListeners.ElementAt(i); + + // If the listener was idle, then he shouldn't be any longer. + if (curListener.isIdle) { + notifyList.AppendObject(curListener.observer); + curListener.isIdle = false; + } + + // Check if the listener is the next one to timeout. + mDeltaToNextIdleSwitchInS = + std::min(mDeltaToNextIdleSwitchInS, curListener.reqIdleTime); + } + + // When we are done, then we wont have anyone idle. + mIdleObserverCount = 0; + + // Restart the idle timer, and do so before anyone can delay us. + ReconfigureTimer(); + + int32_t numberOfPendingNotifications = notifyList.Count(); + + // Bail if nothing to do. + if (!numberOfPendingNotifications) { + return NS_OK; + } + + // Now send "active" events to all, if any should have timed out already, + // then they will be reawaken by the timer that is already running. + + // We need a text string to send with any state change events. + nsAutoString timeStr; + + timeStr.AppendInt((int32_t)(idleDeltaInMS / PR_MSEC_PER_SEC)); + + // Send the "non-idle" events. + while (numberOfPendingNotifications--) { + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: Reset idle timeout: tell observer %p user is back", + notifyList[numberOfPendingNotifications])); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "Reset idle timeout: tell observer %p user is back", + notifyList[numberOfPendingNotifications]); +#endif + notifyList[numberOfPendingNotifications]->Observe( + this, OBSERVER_TOPIC_ACTIVE, timeStr.get()); + } + return NS_OK; +} + +NS_IMETHODIMP +nsUserIdleService::GetIdleTime(uint32_t* idleTime) { + // Check sanity of in parameter. + if (!idleTime) { + return NS_ERROR_NULL_POINTER; + } + + // Polled idle time in ms. + uint32_t polledIdleTimeMS; + + bool polledIdleTimeIsValid = PollIdleTime(&polledIdleTimeMS); + + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: Get idle time: polled %u msec, valid = %d", + polledIdleTimeMS, polledIdleTimeIsValid)); + + // timeSinceReset is in milliseconds. + TimeDuration timeSinceReset = TimeStamp::Now() - mLastUserInteraction; + uint32_t timeSinceResetInMS = timeSinceReset.ToMilliseconds(); + + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: Get idle time: time since reset %u msec", + timeSinceResetInMS)); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "Get idle time: time since reset %u msec", + timeSinceResetInMS); +#endif + + // If we did't get pulled data, return the time since last idle reset. + if (!polledIdleTimeIsValid) { + // We need to convert to ms before returning the time. + *idleTime = timeSinceResetInMS; + return NS_OK; + } + + // Otherwise return the shortest time detected (in ms). + *idleTime = std::min(timeSinceResetInMS, polledIdleTimeMS); + + return NS_OK; +} + +bool nsUserIdleService::PollIdleTime(uint32_t* /*aIdleTime*/) { + // Default behavior is not to have the ability to poll an idle time. + return false; +} + +nsresult nsUserIdleService::GetDisabled(bool* aResult) { + *aResult = mDisabled; + return NS_OK; +} + +nsresult nsUserIdleService::SetDisabled(bool aDisabled) { + mDisabled = aDisabled; + return NS_OK; +} + +void nsUserIdleService::StaticIdleTimerCallback(nsITimer* aTimer, + void* aClosure) { + static_cast<nsUserIdleService*>(aClosure)->IdleTimerCallback(); +} + +void nsUserIdleService::IdleTimerCallback(void) { + // Remember that we no longer have a timer running. + mCurrentlySetToTimeoutAt = TimeStamp(); + + // Find the last detected idle time. + uint32_t lastIdleTimeInMS = static_cast<uint32_t>( + (TimeStamp::Now() - mLastUserInteraction).ToMilliseconds()); + // Get the current idle time. + uint32_t currentIdleTimeInMS; + + if (NS_FAILED(GetIdleTime(¤tIdleTimeInMS))) { + MOZ_LOG(sLog, LogLevel::Info, + ("idleService: Idle timer callback: failed to get idle time")); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "Idle timer callback: failed to get idle time"); +#endif + return; + } + + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: Idle timer callback: current idle time %u msec", + currentIdleTimeInMS)); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "Idle timer callback: current idle time %u msec", + currentIdleTimeInMS); +#endif + + // Check if we have had some user interaction we didn't handle previously + // we do the calculation in ms to lessen the chance for rounding errors to + // trigger wrong results. + if (lastIdleTimeInMS > currentIdleTimeInMS) { + // We had user activity, so handle that part first (to ensure the listeners + // don't risk getting an non-idle after they get a new idle indication. + ResetIdleTimeOut(currentIdleTimeInMS); + + // NOTE: We can't bail here, as we might have something already timed out. + } + + // Find the idle time in S. + uint32_t currentIdleTimeInS = currentIdleTimeInMS / PR_MSEC_PER_SEC; + + // Restart timer and bail if no-one are expected to be in idle + if (mDeltaToNextIdleSwitchInS > currentIdleTimeInS) { + // If we didn't expect anyone to be idle, then just re-start the timer. + ReconfigureTimer(); + return; + } + + if (mDisabled) { + MOZ_LOG(sLog, LogLevel::Info, + ("idleService: Skipping idle callback while disabled")); + + ReconfigureTimer(); + return; + } + + // Tell expired listeners they are expired,and find the next timeout + Telemetry::AutoTimer<Telemetry::IDLE_NOTIFY_IDLE_MS> timer; + + // We need to initialise the time to the next idle switch. + mDeltaToNextIdleSwitchInS = UINT32_MAX; + + // Create list of observers that should be notified. + nsCOMArray<nsIObserver> notifyList; + + for (uint32_t i = 0; i < mArrayListeners.Length(); i++) { + IdleListener& curListener = mArrayListeners.ElementAt(i); + + // We are only interested in items, that are not in the idle state. + if (!curListener.isIdle) { + // If they have an idle time smaller than the actual idle time. + if (curListener.reqIdleTime <= currentIdleTimeInS) { + // Then add the listener to the list of listeners that should be + // notified. + notifyList.AppendObject(curListener.observer); + // This listener is now idle. + curListener.isIdle = true; + // Remember we have someone idle. + mIdleObserverCount++; + } else { + // Listeners that are not timed out yet are candidates for timing out. + mDeltaToNextIdleSwitchInS = + std::min(mDeltaToNextIdleSwitchInS, curListener.reqIdleTime); + } + } + } + + // Restart the timer before any notifications that could slow us down are + // done. + ReconfigureTimer(); + + int32_t numberOfPendingNotifications = notifyList.Count(); + + // Bail if nothing to do. + if (!numberOfPendingNotifications) { + MOZ_LOG( + sLog, LogLevel::Debug, + ("idleService: **** Idle timer callback: no observers to message.")); + return; + } + + // We need a text string to send with any state change events. + nsAutoString timeStr; + timeStr.AppendInt(currentIdleTimeInS); + + // Notify all listeners that just timed out. + while (numberOfPendingNotifications--) { + MOZ_LOG( + sLog, LogLevel::Debug, + ("idleService: **** Idle timer callback: tell observer %p user is idle", + notifyList[numberOfPendingNotifications])); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "Idle timer callback: tell observer %p user is idle", + notifyList[numberOfPendingNotifications]); +#endif + nsAutoCString timeCStr; + timeCStr.AppendInt(currentIdleTimeInS); + AUTO_PROFILER_MARKER_TEXT("UserIdle::IdleCallback", OTHER, {}, timeCStr); + notifyList[numberOfPendingNotifications]->Observe(this, OBSERVER_TOPIC_IDLE, + timeStr.get()); + } +} + +void nsUserIdleService::SetTimerExpiryIfBefore(TimeStamp aNextTimeout) { + TimeDuration nextTimeoutDuration = aNextTimeout - TimeStamp::Now(); + + MOZ_LOG( + sLog, LogLevel::Debug, + ("idleService: SetTimerExpiryIfBefore: next timeout %0.f msec from now", + nextTimeoutDuration.ToMilliseconds())); + +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "SetTimerExpiryIfBefore: next timeout %0.f msec from now", + nextTimeoutDuration.ToMilliseconds()); +#endif + + // Bail if we don't have a timer service. + if (!mTimer) { + return; + } + + // If the new timeout is before the old one or we don't have a timer running, + // then restart the timer. + if (mCurrentlySetToTimeoutAt.IsNull() || + mCurrentlySetToTimeoutAt > aNextTimeout) { + mCurrentlySetToTimeoutAt = aNextTimeout; + + // Stop the current timer (it's ok to try'n stop it, even it isn't running). + mTimer->Cancel(); + + // Check that the timeout is actually in the future, otherwise make it so. + TimeStamp currentTime = TimeStamp::Now(); + if (currentTime > mCurrentlySetToTimeoutAt) { + mCurrentlySetToTimeoutAt = currentTime; + } + + // Add 10 ms to ensure we don't undershoot, and never get a "0" timer. + mCurrentlySetToTimeoutAt += TimeDuration::FromMilliseconds(10); + + TimeDuration deltaTime = mCurrentlySetToTimeoutAt - currentTime; + MOZ_LOG( + sLog, LogLevel::Debug, + ("idleService: IdleService reset timer expiry to %0.f msec from now", + deltaTime.ToMilliseconds())); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "reset timer expiry to %0.f msec from now", + deltaTime.ToMilliseconds()); +#endif + + // Start the timer + mTimer->InitWithNamedFuncCallback( + StaticIdleTimerCallback, this, deltaTime.ToMilliseconds(), + nsITimer::TYPE_ONE_SHOT, "nsUserIdleService::SetTimerExpiryIfBefore"); + } +} + +void nsUserIdleService::ReconfigureTimer(void) { + // Check if either someone is idle, or someone will become idle. + if ((mIdleObserverCount == 0) && UINT32_MAX == mDeltaToNextIdleSwitchInS) { + // If not, just let any existing timers run to completion + // And bail out. + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: ReconfigureTimer: no idle or waiting observers")); +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, + "ReconfigureTimer: no idle or waiting observers"); +#endif + return; + } + + // Find the next timeout value, assuming we are not polling. + + // We need to store the current time, so we don't get artifacts from the time + // ticking while we are processing. + TimeStamp curTime = TimeStamp::Now(); + + TimeStamp nextTimeoutAt = + mLastUserInteraction + + TimeDuration::FromSeconds(mDeltaToNextIdleSwitchInS); + + TimeDuration nextTimeoutDuration = nextTimeoutAt - curTime; + + MOZ_LOG(sLog, LogLevel::Debug, + ("idleService: next timeout %0.f msec from now", + nextTimeoutDuration.ToMilliseconds())); + +#ifdef MOZ_WIDGET_ANDROID + __android_log_print(LOG_LEVEL, LOG_TAG, "next timeout %0.f msec from now", + nextTimeoutDuration.ToMilliseconds()); +#endif + + SetTimerExpiryIfBefore(nextTimeoutAt); +} |