Here is a high-level architecture diagram to understand how data flows between different components

• The Repository returns a LiveData instance of the response object.
• In the ViewModel, the LiveData instance is passed as a parameter to map() or switchMap() . The transformations are calculated lazily, and will run only when the returned LiveData is being observed.
• View is responsible for observing the LiveData and updating the UI once the response is received.

In the sample app, fetchDetails() returns a list of ‘DogBreed’ objects which is wrapped in ‘Resource’ before storing in LiveData with the help of asLiveData() extension.

fetchBreedDetails(id) requires a ‘DogBreed’ id as a param to return an object of ‘BreedDetails’ which is stored as LiveData in a similar manner.

Here, depending upon the failure/success of the API call, we wrap the response in Resource.error or Resource.success accordingly and store it in a MutableLiveData and return the same.

Transformations.map()

This is a very simple and straightforward way to create the transformation. This method takes in LiveData as a function parameter and observes it for any change in value.

Whenever a new value is available, it applies the transformation on the data and returns the transformed LiveData to the observers.

• In the sample app, we are transforming List<Resource<DogBreeds>> to List<String> which is needed to populate the ‘Select Dog Breed Spinner’ on the UI.
• In case of a failed API call, the error can be handled and the UI could be updated accordingly.
• Notice that a ‘LifecycleOwner’ is not needed here, although, without an observer, the transformation will never get triggered.
• The LiveData that is being returned from fetchDogBreedList() is being observed from the fragment.

With this, we have achieved the first task of populating the spinner with a list of dog breeds. Now, we need to fetch the details of the user-selected item. We can make a network call in the click listener of the spinner but there is a more cleaner and concise way of implementing this functionality using switchMap()

Transformations.switchMap()

• selectedBreedLiveData is set whenever a new spinner value is selected. This is done in the onItemSelectedListener of the Spinner in the fragment
• Observing breedDetailsLiveData will trigger a callback whenever selectedBreedLiveData is set.
• Similar to map(), ‘LifecycleOwner’ is not needed here.
• The LiveData that is being returned from fetchBreedDetails() is being observed from the fragment.

Hence, this kind of chaining helps us in performing tasks that are dependant on each other. The architecture can look much cleaner and concise as long as you don’t chain too many tasks.

That’s all for this article, let me know your thoughts on this approach.

You can find the sample app on GitHub:

KunalChaubal/LiveDataTransformExample A sample app to showcase Transformations.map() and switchMap() to transform LiveData … github.com

Feel free to Fork it/contribute to it.

Happy Coding!