reloader.js

const launchScreen = LaunchScreen.hold();

Reloader = {

  _options: {},

  configure(options) {
    check(options, {
      check: Match.Optional(Match.OneOf('everyStart', 'firstStart', false)),
      checkTimer: Match.Optional(Match.Integer),
      refresh: Match.Optional(Match.OneOf('startAndResume', 'start', 'instantly')),
      idleCutoff: Match.Optional(Match.Integer),
      launchScreenDelay: Match.Optional(Match.Integer)
    });

    _.extend(this._options, options);

    this._onPageLoad();
  },

  updateAvailable: new ReactiveVar(false),

  prereload() {
    // Show the splashscreen
    navigator.splashscreen.show();

    // Set the refresh flag
    localStorage.setItem('reloaderWasRefreshed', Date.now());
  },

  reload() {
    this.prereload();

    cordova.exec(() => {
      // We'd like to make the browser reload the page using location.replace()
      // instead of location.reload(), because this avoids validating assets
      // with the server if we still have a valid cached copy. This doesn't work
      // when the location contains a hash however, because that wouldn't reload
      // the page and just scroll to the hash location instead.
      if (window.location.hash || window.location.href.endsWith('#')) {
        window.location.reload();
      } else {
        window.location.replace(window.location.href);
      }
    }, console.error, 'WebAppLocalServer', 'switchPendingVersion', []);

  },


  // Should check if a cold start and (either everyStart is set OR firstStart
  // is set and it's our first start)
  _shouldCheckForUpdateOnStart() {
    const isColdStart = !localStorage.getItem('reloaderWasRefreshed');
    return isColdStart &&
      (
        this._options.check === 'everyStart' ||
        (
          this._options.check === 'firstStart' &&
          !localStorage.getItem('reloaderLastStart')
        )
      );
  },

  // Check if the idleCutoff is set AND we exceeded the idleCutOff limit AND the everyStart check is set
  _shouldCheckForUpdateOnResume() {
    // In case a pause event was missed, assume it didn't make the cutoff
    if (!localStorage.getItem('reloaderLastPause')) {
      return false;
    }

    // Grab the last time we paused
    const lastPause = Number(localStorage.getItem('reloaderLastPause'));

    // Calculate the cutoff timestamp
    const idleCutoffAt = Number(Date.now() - this._options.idleCutoff);

    return (
      this._options.idleCutoff &&
      lastPause < idleCutoffAt &&
      this._options.check === 'everyStart'
    );
  },

  _waitForUpdate(computation) {
    // Check if we have a HCP after the check timer is up
    Meteor.setTimeout(() => {
      // If there is a new version available
      if (this.updateAvailable.get()) {
        this.reload();
      } else {

        // Stop waiting for update
        if (computation) {
          computation.stop()
        }

        launchScreen.release();
        navigator.splashscreen.hide();
      }
    }, this._options.checkTimer);
  },

  _checkForUpdate() {
    if (this.updateAvailable.get()) {
      // Check for an even newer update
      this._waitForUpdate()

    } else {

      // Wait until update is available, or give up on timeout
      Tracker.autorun((c) => {

        if (this.updateAvailable.get()) {
          this.reload();
          return;
        }

        this._waitForUpdate(c)
      });

    }
  },

  _onPageLoad() {
    if (this._shouldCheckForUpdateOnStart()) {
      this._checkForUpdate();

    } else {
      Meteor.setTimeout(function () {
        launchScreen.release();
        // Reset the reloaderWasRefreshed flag
        localStorage.removeItem('reloaderWasRefreshed');
      }, this._options.launchScreenDelay); // Short delay helps with white flash
    }
  },

  _onResume() {
    const shouldCheck = this._shouldCheckForUpdateOnResume();
    localStorage.removeItem('reloaderLastPause');

    if (shouldCheck) {
      navigator.splashscreen.show();
      this._checkForUpdate();

      // If we don't need to do an additional check
    } else {
      // Check if there's a new version available already AND we need to refresh on resume
      if (this.updateAvailable.get() && this._options.refresh === 'startAndResume') {
        this.reload();
      }
    }
  },

  // https://github.com/meteor/meteor/blob/devel/packages/reload/reload.js#L104-L122
  _onMigrate(retry) {
    if (this._options.refresh === 'instantly') {
      this.prereload();
      return [true, {}];

    } else {
      // Set the flag
      this.updateAvailable.set(true);
      // Don't refresh yet
      return [false];
    }
  }

};


// Set the last start flag
localStorage.setItem('reloaderLastStart', Date.now());

// Watch for the app resuming
document.addEventListener('resume', function () {
  Reloader._onResume();
}, false);


localStorage.removeItem('reloaderLastPause');

// Watch for the device pausing
document.addEventListener('pause', function () {
  // Save to localStorage
  localStorage.setItem('reloaderLastPause', Date.now());
}, false);


// Capture the reload
Reload._onMigrate('mslobodan:reloader', function (retry) {
  return Reloader._onMigrate(retry);
});


// Update available template helper
Template.registerHelper('updateAvailable', function () {
  return Reloader.updateAvailable.get();
});

// Update available event
$(document).on('click', '[reloader-update]', function (event) {
  Reloader.reload();
});