React to foreground and background events with ProcessLifecycleOwner

Photo by Mike Wilson on Unsplash

As part of Android Architecture Components Google introduced lifecycle-aware components designed to handle lifecycle events outside of your view layer (Activities and Fragments). All you need to do is create a lifecycle observer for a particular view (lifecycle owner) and subscribe to lifecycle events of your choice. As a result, the code becomes more modular, easier to read and test.

The latest news related to the library came recently from Florina Muntenescu.

A bit of background

There are various reasons why you’d want to detect app open and close events. Perhaps you need to track these events for analytics purposes. Or you may need to message a user on app startup (for instance, communicate updates to privacy policy, announce new content was published, etc.).

Reacting to app foreground events gets more complicated when this message needs to work when deep linking to a specific Activity or coding Instant Apps. It’s all doable but usually requires quite a bit of code involving analyzing Activities in the stack to determine when the app opens or closes.

ProcessLifecycleOwner to the rescue

ProcessLifecycleOwner solves this problem beautifully. It is a special kind of LifecycleOwner that is a composite of all of your Activities. It provides lifecycle for the whole application process. We can use it to react on our app coming to the foreground or going to the background with very little code, as we will see below.

Feel free to skip reading and jump into the source code directly at http://github.com/jshvarts/AppLifecycleDemo.

The example below is written in Kotlin. It uses Android Lifecycle Components library and Dagger 2.12 to inject dependencies.

Be sure to include the lifecycle library dependency. For a complete Gradle setup, see the repo on GitHub.

Lifecycle Owner setup

Create a custom Application class that will provide access to its lifecycle events to our custom AppLifecycleObserver via ProcessLifecycleOwner class.a

Lifecycle Observer setup

Next, create AppLifecycleObserver that implements LifecycleObserver and observes our app’s onStart() and onStop() lifecycle events.

Here we simply display different Toast messages when the app is coming to the foreground or going to the background.

The Context, needed to display the Toasts, is injected by Dagger — check out the AppModule in the repo for details.

Toast.showAfterCanceling(toastToCancel: Toast) is a custom extension function to simplify removing a Toast (if any) prior to displaying a new one.That’s it! It’s time to test it.

Testing foreground behavior

Launch the app and observe the following:

“Welcome” Toast when app is foregrounded

Rotate the device to cause our MainActivity to be recreated. The Toast will not show up again since the lifecycle we are observing is that of the entire app, not a specific Activity.

Background the app and foreground it again to see the “Welcome to the app!” message again.

Testing background behavior

Background the app to observe the following:

“Goodbye” Toast when app is backgrounded

ProcessLifecycleOwner internals

1. Lifecycle.Event.ON_START will only execute once while the app is in foreground regardless of how many Activities are launched. That’s why the Toast message above was displayed only once.
2. Lifecycle.Event.ON_DESTROY will never fire.
3. Lifecycle.Event.ON_PAUSE and Lifecycle.Event.ON_STOP events are dispatched with a delay of 700ms after the last activity passed through them. This delay is long enough to guarantee that ProcessLifecycleOwner won’t send any events if activities are destroyed and recreated due to a configuration change. You would need to decide if this delay is acceptable in your particular case when reacting to app going to the background.

I hope this helps! Feel free to check out the source code at http://github.com/jshvarts/AppLifecycleDemo

Visit my Android blog to read about Jetpack Compose and other Android topics