Service worker communicationlink

Importing ServiceWorkerModule into your AppModule doesn't just register the service worker, it also provides a few services you can use to interact with the service worker and control the caching of your app.

Prerequisiteslink

A basic understanding of the following:

• Getting Started with Service Workers.

SwUpdate servicelink

The SwUpdate service gives you access to events that indicate when the service worker has discovered an available update for your app or when it has activated such an update—meaning it is now serving content from that update to your app.

The SwUpdate service supports four separate operations:

• Getting notified of available updates. These are new versions of the app to be loaded if the page is refreshed.
• Getting notified of update activation. This is when the service worker starts serving a new version of the app immediately.
• Asking the service worker to check the server for new updates.
• Asking the service worker to activate the latest version of the app for the current tab.

Available and activated updateslink

The two update events, available and activated, are Observable properties of SwUpdate:

      
        content_copy
      
      @Injectable()
export class LogUpdateService {

  constructor(updates: SwUpdate) {
    updates.available.subscribe(event => {
      console.log('current version is', event.current);
      console.log('available version is', event.available);
    });
    updates.activated.subscribe(event => {
      console.log('old version was', event.previous);
      console.log('new version is', event.current);
    });
  }
}
    

You can use these events to notify the user of a pending update or to refresh their pages when the code they are running is out of date.

Checking for updateslink

It's possible to ask the service worker to check if any updates have been deployed to the server. You might choose to do this if you have a site that changes frequently or want updates to happen on a schedule.

Do this with the checkForUpdate() method:

      
        content_copy
      
      import { ApplicationRef, Injectable } from '@angular/core';
import { SwUpdate } from '@angular/service-worker';
import { concat, interval } from 'rxjs';
import { first } from 'rxjs/operators';

@Injectable()
export class CheckForUpdateService {

  constructor(appRef: ApplicationRef, updates: SwUpdate) {
    // Allow the app to stabilize first, before starting polling for updates with `interval()`.
    const appIsStable$ = appRef.isStable.pipe(first(isStable => isStable === true));
    const everySixHours$ = interval(6 * 60 * 60 * 1000);
    const everySixHoursOnceAppIsStable$ = concat(appIsStable$, everySixHours$);

    everySixHoursOnceAppIsStable$.subscribe(() => updates.checkForUpdate());
  }
}
    

This method returns a Promise which indicates that the update check has completed successfully, though it does not indicate whether an update was discovered as a result of the check. Even if one is found, the service worker must still successfully download the changed files, which can fail. If successful, the available event will indicate availability of a new version of the app.

Forcing update activationlink

If the current tab needs to be updated to the latest app version immediately, it can ask to do so with the activateUpdate() method:

      
        content_copy
      
      @Injectable()
export class PromptUpdateService {

  constructor(updates: SwUpdate) {
    updates.available.subscribe(event => {
      if (promptUser(event)) {
        updates.activateUpdate().then(() => document.location.reload());
      }
    });
  }
}
    

Doing this could break lazy-loading into currently running apps, especially if the lazy-loaded chunks use filenames with hashes, which change every version.

More on Angular service workerslink

You may also be interested in the following:

• Service Worker in Production.