DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Header

Mercurial (d960c56b609c)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
/* -*- 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 "nsIdleService.h"
#include "nsString.h"
#include "nsIObserverService.h"
#include "nsIServiceManager.h"
#include "nsDebug.h"
#include "nsCOMArray.h"
#include "nsXULAppAPI.h"
#include "prinrval.h"
#include "mozilla/Logging.h"
#include "prtime.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;

// interval in milliseconds between internal idle time requests.
#define MIN_IDLE_POLL_INTERVAL_MSEC (5 * PR_MSEC_PER_SEC) /* 5 sec */

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

////////////////////////////////////////////////////////////////////////////////
//// nsIdleServiceDaily

NS_IMPL_ISUPPORTS(nsIdleServiceDaily, nsIObserver, nsISupportsWeakReference)

NS_IMETHODIMP
nsIdleServiceDaily::Observe(nsISupports*, const char* aTopic, const char16_t*) {
  MOZ_LOG(
      sLog, LogLevel::Debug,
      ("nsIdleServiceDaily: Observe '%s' (%d)", aTopic, mShutdownInProgress));

  if (strcmp(aTopic, "profile-after-change") == 0) {
    // We are back. Start sending notifications again.
    mShutdownInProgress = false;
    return NS_OK;
  }

  if (strcmp(aTopic, "xpcom-will-shutdown") == 0 ||
      strcmp(aTopic, "profile-change-teardown") == 0) {
    mShutdownInProgress = true;
  }

  if (mShutdownInProgress || strcmp(aTopic, OBSERVER_TOPIC_ACTIVE) == 0) {
    return NS_OK;
  }
  MOZ_ASSERT(strcmp(aTopic, OBSERVER_TOPIC_IDLE) == 0);

  MOZ_LOG(sLog, LogLevel::Debug,
          ("nsIdleServiceDaily: 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,
          ("nsIdleServiceDaily: 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,
          ("nsIdleServiceDaily: 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, "nsIdleServiceDaily::Observe");

  return NS_OK;
}

nsIdleServiceDaily::nsIdleServiceDaily(nsIIdleService* aIdleService)
    : mIdleService(aIdleService),
      mTimer(NS_NewTimer()),
      mCategoryObservers(OBSERVER_TOPIC_IDLE_DAILY),
      mShutdownInProgress(false),
      mExpectedTriggerTime(0),
      mIdleDailyTriggerWait(DAILY_SIGNIFICANT_IDLE_SERVICE_SEC) {}

void nsIdleServiceDaily::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 nowSec = static_cast<int32_t>(PR_Now() / PR_USEC_PER_SEC);
  int32_t lastDaily = Preferences::GetInt(PREF_LAST_DAILY, 0);
  if (lastDaily < 0 || lastDaily > nowSec) {
    // The time is bogus, use default.
    lastDaily = 0;
  }
  int32_t secondsSinceLastDaily = nowSec - lastDaily;

  MOZ_LOG(sLog, LogLevel::Debug,
          ("nsIdleServiceDaily: 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,
            ("nsIdleServiceDaily: 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,
            ("nsIdleServiceDaily: 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,
            ("nsIdleServiceDaily: 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,
        "nsIdleServiceDaily::Init");
  }

  // Register for when we should terminate/pause
  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
  if (obs) {
    MOZ_LOG(sLog, LogLevel::Debug,
            ("nsIdleServiceDaily: Registering for system event observers."));
    obs->AddObserver(this, "xpcom-will-shutdown", true);
    obs->AddObserver(this, "profile-change-teardown", true);
    obs->AddObserver(this, "profile-after-change", true);
  }
}

nsIdleServiceDaily::~nsIdleServiceDaily() {
  if (mTimer) {
    mTimer->Cancel();
    mTimer = nullptr;
  }
}

void nsIdleServiceDaily::StageIdleDaily(bool aHasBeenLongWait) {
  NS_ASSERTION(mIdleService, "No idle service available?");
  MOZ_LOG(sLog, LogLevel::Debug,
          ("nsIdleServiceDaily: 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 nsIdleServiceDaily::DailyCallback(nsITimer* aTimer, void* aClosure) {
  MOZ_LOG(sLog, LogLevel::Debug, ("nsIdleServiceDaily: DailyCallback running"));
#ifdef MOZ_WIDGET_ANDROID
  __android_log_print(LOG_LEVEL, LOG_TAG, "DailyCallback running");
#endif

  nsIdleServiceDaily* self = static_cast<nsIdleServiceDaily*>(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,
            ("nsIdleServiceDaily: 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, "nsIdleServiceDaily::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.
 *
 */

////////////////////////////////////////////////////////////////////////////////
//// nsIdleService

namespace {
nsIdleService* gIdleService;
}  // namespace

already_AddRefed<nsIdleService> nsIdleService::GetInstance() {
  RefPtr<nsIdleService> instance(gIdleService);
  return instance.forget();
}

nsIdleService::nsIdleService()
    : mCurrentlySetToTimeoutAt(TimeStamp()),
      mIdleObserverCount(0),
      mDeltaToNextIdleSwitchInS(UINT32_MAX),
      mLastUserInteraction(TimeStamp::Now()) {
  MOZ_ASSERT(!gIdleService);
  gIdleService = this;
  if (XRE_IsParentProcess()) {
    mDailyIdle = new nsIdleServiceDaily(this);
    mDailyIdle->Init();
  }
}

nsIdleService::~nsIdleService() {
  if (mTimer) {
    mTimer->Cancel();
  }

  MOZ_ASSERT(gIdleService == this);
  gIdleService = nullptr;
}

NS_IMPL_ISUPPORTS(nsIdleService, nsIIdleService, nsIIdleServiceInternal)

NS_IMETHODIMP
nsIdleService::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 (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);

  if (!mArrayListeners.AppendElement(listener)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

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

  // Ensure timer is running.
  ReconfigureTimer();

  return NS_OK;
}

NS_IMETHODIMP
nsIdleService::RemoveIdleObserver(nsIObserver* aObserver, uint32_t aTimeInS) {
  NS_ENSURE_ARG_POINTER(aObserver);
  NS_ENSURE_ARG(aTimeInS);

  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
nsIdleService::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
nsIdleService::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 nsIdleService::PollIdleTime(uint32_t* /*aIdleTime*/) {
  // Default behavior is not to have the ability to poll an idle time.
  return false;
}

bool nsIdleService::UsePollMode() {
  uint32_t dummy;
  return PollIdleTime(&dummy);
}

void nsIdleService::StaticIdleTimerCallback(nsITimer* aTimer, void* aClosure) {
  static_cast<nsIdleService*>(aClosure)->IdleTimerCallback();
}

void nsIdleService::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(&currentIdleTimeInMS))) {
    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;
  }

  // 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
    notifyList[numberOfPendingNotifications]->Observe(this, OBSERVER_TOPIC_IDLE,
                                                      timeStr.get());
  }
}

void nsIdleService::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, "nsIdleService::SetTimerExpiryIfBefore");
  }
}

void nsIdleService::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

  // Check if we should correct the timeout time because we should poll before.
  if ((mIdleObserverCount > 0) && UsePollMode()) {
    TimeStamp pollTimeout =
        curTime + TimeDuration::FromMilliseconds(MIN_IDLE_POLL_INTERVAL_MSEC);

    if (nextTimeoutAt > pollTimeout) {
      MOZ_LOG(
          sLog, LogLevel::Debug,
          ("idleService: idle observers, reducing timeout to %lu msec from now",
           MIN_IDLE_POLL_INTERVAL_MSEC));
#ifdef MOZ_WIDGET_ANDROID
      __android_log_print(
          LOG_LEVEL, LOG_TAG,
          "idle observers, reducing timeout to %lu msec from now",
          MIN_IDLE_POLL_INTERVAL_MSEC);
#endif
      nextTimeoutAt = pollTimeout;
    }
  }

  SetTimerExpiryIfBefore(nextTimeoutAt);
}