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

# Saving favorite articles

This fragment will display a list of articles that the user has marked as favorites and intends to read later.

The “Favorites” button is a floating action bar that allows the user to save an article in the `Room` database by clicking it. The saved article(s) is then displayed in this fragment.

Let’s look at the code.


class SavedNewsFragment : Fragment(R.layout.fragment_saved_news) {
    lateinit var viewModel: NewsViewModel
    lateinit var favouriteNewsAdapter: FavouriteNewsAdapter

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)


        var binding = FragmentSavedNewsBinding.bind(view)

        setUpRecyclerView(binding)

        val newsRepository = NewsRepository(ArticleDatabase(requireContext() as NewsActivity))
        val viewModelProviderFactory =
            NewsViewModelProvider(activity?.application!!, newsRepository)
        viewModel = ViewModelProvider(this, viewModelProviderFactory).get(NewsViewModel::class.java)

        favouriteNewsAdapter.setOnItemClickListener {
            val favArticle = Article(
                it.id,
                it.author,
                it.content,
                it.description,
                it.publishedAt,
                it.source,
                it.title,
                it.isBookmarked,
                it.url,
                it.urlToImage
            )
            val bundle = Bundle().apply {
                putSerializable("article", favArticle)
            }
            findNavController().navigate(
                R.id.action_savedNewsFragment2_to_articleFragment,
                bundle
            )
        }

        lifecycleScope.launch {
            viewModel.fetchSavedArticles().collect {
                favouriteNewsAdapter.favouriteNewsDifferCallBack.submitList(it)
            }
        }
    }

    private fun setUpRecyclerView(binding: FragmentSavedNewsBinding) {
        favouriteNewsAdapter = FavouriteNewsAdapter()
        binding.SavedNewsRecyclerView.apply {
            adapter = favouriteNewsAdapter
            layoutManager = LinearLayoutManager(activity)
        }
    }

}

We start by declaring three class variables:

```
lateinit var viewModel: NewsViewModel
lateinit var favouriteNewsAdapter: FavouriteNewsAdapter
```
These are class variables that will be assigned values later in the program, and because we used the `lateinit` modifier, we’ll delay their initialization until later on in the program. However, it should be noted that we must assign values to them before accessing them, or the program will terminate unexpectedly with the exception stated below.

```
UninitializedPropertyAccessException: lateinit property viewModel has not been initialized
```
 Using `lateinit` can be useful in situations where we want to postpone the initialization of a variable until a certain condition is met, or until certain dependencies have been satisfied. However, it is important to ensure that the variable is properly initialized before it is accessed in order to avoid runtime errors.

In the `onViewCreated()`, we’ll reference the views using `ViewBinding` to gain access to the view IDs.
Then, we’ll declare a method in the `onViewCreated()` to set up the `RecyclerView`.

Then we are going to declare a method in the `onViewCreated()` to set up the `RecyclerView`.

```
setUpRecyclerView(binding)
```
The `viewModel.fetchSavedArticles()` method is called to get a list of saved articles from the database, which is then submitted to the favouriteNewsAdapter using the `favouriteNewsDifferCallBack.submitList()` method. This is done inside a `lifecycleScope.launch()` block, which is used to launch a coroutine that will run on the lifecycle of the fragment.

```


          lifecycleScope.launch {
            viewModel.fetchSavedArticles().collect {
                favouriteNewsAdapter.favouriteNewsDifferCallBack.submitList(it)
            }
        }
```

We’ll use the adapter’s `setOnItemClickListener` as shown below to set a destination when one of the saved articles in the `RecyclerView` is clicked for a specific action to be performed.

```
    favouriteNewsAdapter.setOnItemClickListener {
            val favArticle = Article(
                it.id,
                it.author,
                it.content,
                it.description,
                it.publishedAt,
                it.source,
                it.title,
                it.isBookmarked,
                it.url,
                it.urlToImage
            )
            val bundle = Bundle().apply {
                putSerializable("article", favArticle)
            }
            findNavController().navigate(
                R.id.action_savedNewsFragment2_to_articleFragment,
                bundle
            )
        }
```
According to the code above, when an article is clicked, the data stored in a bundle of key-value pairs is transferred to the next fragment. The bundle contains a web URL that allows us to open the article in a `WebView` within the article fragment.
Let’s test the application to see if our articles are getting saved in the `Room` database. To test this, make sure the article fragment is running, then click on the “Favorites” button for the article to be sent to the database. When it’s retrieved, the article is displayed in the `SavedNewsFragment`.

Learn how to retrieve saved news from local database.

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

Saved News Fragment

Saving favorite articles