Gain insights into MVVM architecture in Android with Kotlin. Learn about networking with Retrofit, local storage with Room, and pagination. Discover how to build scalable, maintainable apps.

Mastering MVVM architecture with Kotlin-01.png

tarball.tar.gz

postman

The course focuses on the MVVM (Model-View-ViewModel) architecture in Android development using Kotlin. The MVVM is widely recommended due to its robustness, scalability, and ease of maintenance. It is a valuable skill to have for building high-performance Android applications.

Firstly, you will learn the basics of MVVM architecture and its advantages over other approaches to Android development. Then, you'll start from scratch and create layouts for a news application. Next, you'll use the Retrofit and OkHttp networking libraries and get to familiarize yourself with APIs. You'll get hands-on experience in storing data locally via the Room library. Finally, you'll be introduced to both the repository and ViewModel patterns, as well as how to work with the Paging library and deliver data to our fragments.

By the time you’re done with the course, you’ll be able to use MVVM in your Android projects, interact with APIs, store data locally, and implement pagination.

Mastering MVVM Architecture in Android Development using Kotlin

We need to create an instance of a ViewModel.

If we’veve added arguments in the constructor of our ViewModel, then we must create a custom `ViewModelProvider.Factory` to create an instance for our ViewModel.

We need to pass `LiveData` to be observed by the activity or fragment.


We need to initialize the `ViewModel` to help pass our arguments in the activity or fragment.


What is not a reason we would need a custom `ViewModelProvider.Factory`?

What is not a reason we would need a custom <code>ViewModelProvider.Factory</code>?

`LiveData` is immutable, while `MutableLivedata` can be edited using `setValue` and `postValue` methods.

`LiveData` is an observable, while `MutableLiveData` is not.


`MutableLiveData` is a subclass of `LiveData`.


`LiveData` is not synchronized, but `MutableLivedata` is.


Which is not correct about `LiveData` and `MutableLiveData`?


Which is not correct about <code>LiveData</code> and <code>MutableLiveData</code>?

For better separation of concerns. It’s easy for the ViewModel to process data for the views without putting all the logic into the view.

To improve testability by separating the logic from the views. Testing becomes easy because the ViewModel does not have any reference to the object it owns.


To boost communication between different components in the program. Proper interfaces are used to provide data to the views through the ViewModel, bringing these layers together. It’s also easier to control the interaction between these components.


To use a ViewModel to reference views and classes that hold reference to the activity or fragment.


Which is not a reason to use ViewModels?


To hide or separate implementation details, making our app more flexible.

To ensure that the `LiveData` isn’t destroyed when the UI controller is destroyed.


Both the ViewModel and `LiveData` are lifecycle aware.


Why should we initialize and store `LiveData` in our ViewModel instead of a UI controller?

Why should we initialize and store <code>LiveData</code> in our ViewModel instead of a UI controller?

Introduction

MVVM Architecture

Layouts

Layout Design Assessment

API

Android Web Services Assessment

Utility Classes

Repository Pattern

ViewModel Pattern

Android Business Logic Assessment

Views

Conclusion

Appendix

Quiz Yourself on ViewModel Pattern