Web Periodic Background Synchronization

async function registerPeriodicNewsCheck() {
  const registration = await navigator.serviceWorker.ready;
  try {
    await registration.periodicSync.register('fetch-news', {
      minInterval: 24 * 60 * 60 * 1000,
    });
  } catch {
    console.log('Periodic Sync could not be registered!');
  }
}

self.addEventListener('periodicsync', event => {
  event.waitUntil(fetchAndCacheLatestNews());
});

7.1. Process periodic sync registrations

When the user agent starts, run the following steps in parallel:

1. While true:

   1. Wait for minimum periodic sync interval across origins.

   2. Let firedPeriodicSync be false.

   3. While firedPeriodicSync is false:

      1. Wait for some user agent defined amount of time.

         Note: This can be used to group synchronization for different periodic sync registrations into a single device wake-up.

      2. Wait until online.

      3. For each service worker registration registration that is not unregistered, enqueue the following steps to registration’s periodic sync processing queue:

         1. Let origin be the origin associated with periodicSyncRegistration’s service worker registration.

         2. If time of last fire[origin] + the effective minimum sync interval for origin origin is greater than now, continue.

         3. For each periodic sync registration periodicSyncRegistration in registration’s active periodic sync registrations:

            1. If periodicSyncRegistration’s state is not "pending", continue.

            2. If periodicSyncRegistration’s anchor time + periodicSyncRegistration’s minimum interval is greater than now, continue.

            3. Set firedPeriodicSync to true.

            4. Fire a periodicsync event for periodicSyncRegistration.

7.2. Respond to permission revocation

To respond to revocation of the permission with name "periodic-background-sync" for origin origin, the user agent MUST enqueue the following steps to the periodic sync processing queue:

1. For each periodic sync registration registration in active periodic sync registrations whose service worker registration is associated with the same origin as origin:

   1. Remove registration from active periodic sync registrations.

partial interface ServiceWorkerGlobalScope {
    attribute EventHandler onperiodicsync;
};

[Exposed=(Window,Worker)]
partial interface ServiceWorkerRegistration {
  readonly attribute PeriodicSyncManager periodicSync;
};

[Exposed=(Window,Worker)]
interface PeriodicSyncManager {
    Promise<undefined> register(DOMString tag, optional BackgroundSyncOptions options = {});
    Promise<sequence<DOMString>> getTags();
    Promise<undefined> unregister(DOMString tag);
};

dictionary BackgroundSyncOptions {
    [EnforceRange] unsigned long long minInterval = 0;
};

The register(tag, options) method, when invoked, MUST return a new promise promise and enqueue the following steps to the periodic sync processing queue:

1. Let serviceWorkerRegistration be the service worker registration associated with the context object's PeriodicSyncManager.

2. If serviceWorkerRegistration’s active worker is null, reject promise with an InvalidStateError and abort these steps.

3. If the PermissionState for a PermissionDescriptor with name "periodic-background-sync" is not granted, reject promise with a NotAllowedError and abort these steps.

4. Let isBackground, a boolean, be true.

5. For each client in the service worker clients for the serviceWorkerRegistration’s origin:

   1. If client’s frame type is "top-level" or "auxiliary", set isBackground to false.

6. If isBackground is true, reject promise with an InvalidAccessError and abort these steps.

7. Let currentRegistration be the periodic sync registration in serviceWorkerRegistration’s active periodic sync registrations whose tag equals tag if it exists, else null.

8. If currentRegistration is null:

   1. Let newRegistration be a new periodic sync registration.

   2. Set newRegistration’s tag to tag.

   3. Set newRegistration’s minimum interval to options’ minInterval member.

   4. Set newRegistration’s state to "pending".

   5. Set newRegistration’s service worker registration to serviceWorkerRegistration.

   6. Set newRegistration’s anchor time to a timestamp representing now.

   7. Add newRegistration to serviceWorkerRegistration’s active periodic sync registrations.

   8. Resolve promise.

9. Else:

   1. If currentRegistration’s minimum interval is different to options’ minInterval member:

      1. Set currentRegistration’s minimum interval to options’ minInterval member.

   2. Else, if currentRegistration’s state is "firing", set serviceWorkerRegistration’s state to "reregistered-while-firing".

   3. Resolve promise.

The getTags() method when invoked, MUST return a new promise promise and enqueue the following steps to the periodic sync processing queue:

1. Let serviceWorkerRegistration be the service worker registration associated with the context object's PeriodicSyncManager.

2. Let currentTags be a new list.

3. For each registration of serviceWorkerRegistration’s active periodic sync registrations, append registration’s tag to currentTags.

4. Resolve promise with currentTags.

The unregister(tag) method when invoked, MUST return a new promise promise and enqueue the following steps to the periodic sync processing queue:

1. Let serviceWorkerRegistration be the service worker registration associated with the context object's PeriodicSyncManager.

   1. Let currentRegistration be the periodic sync registration in serviceWorkerRegistration’s active periodic sync registrations whose tag equals tag if it exists, else null.

   2. If currentRegistration is not null, remove currentRegistration from serviceWorkerRegistration’s active periodic sync registrations.

   3. Resolve promise.

dictionary PeriodicSyncEventInit : ExtendableEventInit {
    required DOMString tag;
};

[Exposed=ServiceWorker]
interface PeriodicSyncEvent : ExtendableEvent {
    constructor(DOMString type, PeriodicSyncEventInit init);
    readonly attribute DOMString tag;
};

To fire a periodicsync event for a periodic sync registration registration, the user agent MUST run the following steps:

1. Let serviceWorkerRegistration be registration’s service worker registration.

2. If registration is no longer part of serviceWorkerRegistration’s active periodic sync registrations, abort these steps.

3. Assert: registration’s state is "pending".

4. Let retryCount be 0.

5. Set registration’s state to "firing".

6. While true:

   1. Let continue be false.

   2. Let success be false.

   3. Fire functional event "periodicsync" using PeriodicSyncEvent on serviceWorkerRegistration with tag set to registration’s tag. Let dispatchedEvent, an ExtendableEvent, represent the dispatched periodicsync event and run the following steps with dispatchedEvent:

   4. Let waitUntilPromise be the result of waiting for all of dispatchedEvent’s extend lifetime promises.

   5. React to the fulfillment of waitUntilPromise with the following steps:

      1. Set success to true.

      2. Set continue to true.

   6. React to rejection rejection of waitUntilPromise with the following steps:

      1. Set continue to true.

   7. In parallel:

      1. Wait for continue to be true.

      2. Let origin be the origin associated with registration’s service worker registration.

      3. If success is true, set time of last fire for key origin to the current time.

      4. If success is true or retryCount is greater than maximum number of retries or registration’s state is "reregistered-while-firing", then:

         1. Set registration’s state to "pending".

         2. Set registration’s anchor time to a timestamp representing now.

         3. Abort these steps.

   8. Increment retryCount.

   9. Wait for a small back-off time based on retryCount.