/* -*- 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); }