45. Working with Android Lifecycle-Aware Components

The earlier chapter entitled “Understanding Android Application and Activity Lifecycles” described the use of lifecycle methods to track lifecycle state changes within a UI controller such as an activity or fragment. One of the main problems with these methods is that they place the burden of handling lifecycle changes onto the UI controller. On the surface this might seem like the logical approach since the UI controller is, after all, the object going through the state change. The fact is, however, that the code that is typically impacted by the state change invariably resides in other classes within the app. This led to complex code appearing in the UI controller that needed to manage and manipulate other objects in response to changes in lifecycle state. Clearly this is a scenario best avoided when following the Android architectural guidelines.

A much cleaner and logical approach would be for the objects within...

45.1 Lifecycle Awareness

An object is said to be lifecycle-aware if it is able to detect and respond to changes in the lifecycle state of other objects within an app. Some Android components, LiveData being a prime example, are already lifecycle-aware. It is also possible to configure any class to be lifecycle-aware by implementing the LifecycleObserver interface within the class.

45.2 Lifecycle Owners

Lifecycle-aware components can only observe the status of objects that are lifecycle owners. Lifecycle owners implement the LifecycleOwner interface and are assigned a companion Lifecycle object which is responsible for storing the current state of the component and providing state information to lifecycle observers. Most standard Android Framework components (such as activity and fragment classes) are lifecycle owners. Custom classes may also be configured as lifecycle owners by using the LifecycleRegistry class and implementing the LifecycleObserver interface. For example:

class SampleOwner: LifecycleOwner {

 

    private val lifecycleRegistry: LifecycleRegistry

 

    init {

        lifecycleRegistry = LifecycleRegistry(this)

        lifecycle.addObserver(DemoObserver())

    }

 

...

45.3 Lifecycle Observers

In order for a lifecycle-aware component to observe the state of a lifecycle owner it must implement the LifecycleObserver interface and contain event listener handlers for any lifecycle change events it needs to observe.

class DemoObserver: LifecycleObserver {

    // Lifecycle event methods go here

}

An instance of this observer class is then created and added to the list of observers maintained by the Lifecycle object.

lifecycle.addObserver(DemoObserver())

An observer may also be removed from the Lifecycle object at any time if it no longer needs to track the lifecycle state.

Figure 45-1 illustrates the relationship between the key elements that provide lifecycle awareness:

Figure 45-1

45.4 Lifecycle States and Events

When the status of a lifecycle owner changes, the assigned Lifecycle object will be updated with the new state. At any given time, a lifecycle owner will be in one of the following five states:

•Lifecycle.State.INITIALIZED

•Lifecycle.State.CREATED

•Lifecycle.State.STARTED

•Lifecycle.State.RESUMED

•Lifecycle.State.DESTROYED

As the component transitions through the different states, the Lifecycle object will trigger events on any observers that have been added to the list. The following events are available for implementation within the lifecycle observer:

•Lifecycle.Event.ON_CREATE

•Lifecycle.Event.ON_START

•Lifecycle.Event.ON_RESUME

•Lifecycle.Event.ON_PAUSE

•Lifecycle.Event.ON_STOP

•Lifecycle.Event.ON_DESTROY

•Lifecycle.Event.ON_ANY

Annotations are used within the observer class to associate methods with lifecycle events. The...

45.5 Summary

This chapter has introduced the basics of lifecycle awareness and the classes and interfaces of the Android Lifecycle package included with Android Jetpack. The package contains a number of classes and interfaces that are used to create lifecycle owners, lifecycle observers and lifecycle-aware components. A lifecycle owner has assigned to it a Lifecycle object that maintains a record of the owners state and a list of subscribed observers. When the owner’s state changes, the observer is notified via lifecycle event methods so that it can respond to the change.

The next chapter will create an Android Studio project that demonstrates how to work with and create lifecycle-aware components including the creation of both lifecycle observers and owners, and the handling of lifecycle state changes and events.