DEV Community

Cover image for Stop/Restart Requests When User Is Inactive using Angular, RxJS, and Page Visibility API
nightwolfdev
nightwolfdev

Posted on • Updated on • Originally published at nightwolf.dev

Stop/Restart Requests When User Is Inactive using Angular, RxJS, and Page Visibility API

It’s common for websites or apps to request fresh data on a set interval. What if the user isn’t looking at your website or app anymore? What if they minimized the browser or switched to a different tab or app? Let’s learn how to stop and restart network requests using the Page Visibility API!

Setup

We want to create a service that will be responsible for getting a random quote from the Quotable API. We need to import some things we’ll use within the service. Let’s get those set up now.

import { HttpClient } from '@angular/common/http';

import { BehaviorSubject, fromEvent, Observable, Subject, timer } from 'rxjs';
import { map, repeatWhen, switchMap, takeUntil, tap } from 'rxjs/operators';
Enter fullscreen mode Exit fullscreen mode

Let’s define an interface for what the Quote will look like.

interface Quote {
  _id: string;
  authorSlug: string;
  content: string;
  dateAdded: string;
  dateModified: string;
  length: number;
  tags: string[];
}
Enter fullscreen mode Exit fullscreen mode

Let’s set up the variables we’ll be using as well.

private readonly _restartTimer = new Subject<void>();
private readonly _stopTimer = new Subject<void>();

private readonly _randomQuote = new BehaviorSubject<Quote | null>(null);

readonly randomQuote$ = this._randomQuote.asObservable();
Enter fullscreen mode Exit fullscreen mode

To display the actual quote, we can use the async pipe to subscribe to the observable we created called randomQuote$.

<blockquote *ngIf="randomQuote$ | async as randomQuote">
  {{ randomQuote.content }}
</blockquote>
Enter fullscreen mode Exit fullscreen mode

Get Random Quote

We want to use the HttpClient to make HTTP requests to the Quotable API. Within the service’s constructor, pass in the following:

constructor(private http: HttpClient) {}
Enter fullscreen mode Exit fullscreen mode

Now let’s create a function called getRandomQuote. It will make a GET request to the Quotable API and return a random quote. The returned quote will be passed to the randomQuote BehaviorSubject.

private getRandomQuote(): Observable<Quote> {
  return this.http.get<Quote>('https://api.quotable.io/random').pipe(
    tap(quote => this._randomQuote.next(quote))
  );
}
Enter fullscreen mode Exit fullscreen mode

Get Random Quote Every Minute

Now that we can get a random quote, let’s try getting one every minute! We’ll need the RxJS timer function to run every minute and the RxJS switchMap operator to switch to the observable that gets the random quote after a minute has passed.

Create a function called createTimer. It will create the timer and get a random quote every minute. The time is in milliseconds so 60,000 milliseconds equals 1 minute.

private createTimer(): void {
  timer(0, 60000).pipe(
    switchMap(() => this.getRandomQuote())
  ).subscribe();
}
Enter fullscreen mode Exit fullscreen mode

Stop/Restart Timer

We need a way to stop and restart the timer. Let’s create two functions for that called restartTimer and stopTimer. Both will call next on their respective Subjects to trigger the action.

private restartTimer(): void {
  this._restartTimer.next();
}

private stopTimer(): void {
  this._stopTimer.next();
}
Enter fullscreen mode Exit fullscreen mode

Now let’s update our createTimer function and add in a couple more operators. The takeUntil operator will listen for the stopTimer Subject to trigger. If it is triggered, it will stop the timer. The repeatWhen operator will listen for the restartTimer Subject to trigger. If it is triggered, it will restart the timer.

private createTimer(): void {
  timer(0, 60000).pipe(
    takeUntil(this._stopTimer),
    repeatWhen(() => this._restartTimer),
    switchMap(() => this.getRandomQuote())
  ).subscribe();
}
Enter fullscreen mode Exit fullscreen mode

Page Visibility API

We’re getting a random quote every minute, but what if the user isn’t looking at our website or app anymore? What if they minimized the browser or switched to a different tab or app? Let’s stop getting a random quote every minute until the user comes back.

There is a helpful event called visibilitychange that we can listen for. It provides a visibilityState property that will tell you whether the page content is visible or hidden to the user.

Create a function called onVisibilityChange that will listen for the visibilitychange event. If the visibility state is visible, we can restart the timer. If not, stop the timer.

private onVisibilityChange(): void {
  fromEvent(document, 'visibilitychange').pipe(
    tap((event: Event) => {
      const state = (event.target as Document).visibilityState;

     if (state === 'visible') {
        this.restartTimer();
      } else {
        this.stopTimer();
      }
    })
  ).subscribe();
}
Enter fullscreen mode Exit fullscreen mode

All that’s left to do is call the createTimer and onVisibilityChange functions in the constructor.

constructor(private http: HttpClient) {
  this.createTimer();
  this.onVisibilityChange();
}
Enter fullscreen mode Exit fullscreen mode

Congrats on saving server resources when the user isn’t actively using your website or app!


Visit our website at https://nightwolf.dev and follow us on Twitter!

Top comments (0)