Merge pull request #17 from reactivedroid/livedata-to-stateflow

Migration from LiveData to StateFlow

Author: reactivedroid

README.md

@@ -4,7 +4,7 @@
 # TvFlix :tv: 
 
 The aim of this app is to replicate the high level functionality of www.tvmaze.com and showcase an android app out of it. 
-It connects with [TVDB API](api.thetvdb.com) to give you popular shows and let you mark anyone as favorite.
+It connects with [TVDB API](https://api.thetvdb.com) to give you popular shows and let you mark anyone as favorite.
 TvFlix consists of 3 pieces of UI right now:
 1. Home with Popular Shows
 2. Favorites
@@ -17,14 +17,14 @@ This app is under development. :construction_worker: :hammer_and_wrench:
 ## Android Development and Architecture
 
 * The entire codebase is in [Kotlin](https://kotlinlang.org/)
-* Uses Kotlin [Coroutines](https://kotlinlang.org/docs/reference/coroutines/coroutines-guide.html)
-* Uses MVVM Architecture by [Architecture Components](https://developer.android.com/topic/libraries/architecture/). Room, LiveData, ViewModel, Paging
+* Uses Kotlin [Coroutines](https://kotlinlang.org/docs/reference/coroutines/coroutines-guide.html).
+* Uses MVVM Architecture by [Architecture Components](https://developer.android.com/topic/libraries/architecture/). Room, ViewModel, Paging
 * Uses [Hilt Android](https://developer.android.com/training/dependency-injection/hilt-android) with [Dagger](https://dagger.dev/) for dependency injection
 * Unit Testing by [Mockito](https://github.com/mockito/mockito)
 * Tests Coroutines and architecture components like ViewModel
 * UI Test by [Espresso](https://developer.android.com/training/testing/espresso) based on [Robot Pattern](https://academy.realm.io/posts/kau-jake-wharton-testing-robots/)
-
-*Note* For reference, the Java Codebase has been tagged on `tvmaze_java`. Just checkout the tag and you are in TvMaze Java Land.
+* Uses [Kotlin Coroutines Test](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-test/) to unit test Kotlin Coroutines
+* Uses [StateFlow](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-state-flow/) as a replacement over LiveData as a state-holder observable
 
 ## Further Reading
 

app/build.gradle.kts

@@ -109,7 +109,6 @@ dependencies {
     implementation(Deps.AndroidX.Lifecycle.extensions)
     kapt(Deps.AndroidX.Lifecycle.compiler)
     implementation(Deps.AndroidX.Lifecycle.viewmodel)
-    implementation(Deps.AndroidX.Lifecycle.livedata)
     implementation(Deps.AndroidX.Paging.runtime)
     testImplementation(Deps.AndroidX.Paging.common)
     implementation(Deps.AndroidX.Room.runtime)

app/src/main/java/com/android/tvmaze/di/CoroutineDispatcherProvider.kt

@@ -0,0 +1,20 @@
+package com.android.tvmaze.di
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers.Default
+import kotlinx.coroutines.Dispatchers.IO
+import kotlinx.coroutines.Dispatchers.Main
+import javax.inject.Inject
+
+/**
+ * Provide coroutines context.
+ */
+data class CoroutinesDispatcherProvider(
+    val main: CoroutineDispatcher,
+    val computation: CoroutineDispatcher,
+    val io: CoroutineDispatcher
+) {
+
+    @Inject
+    constructor() : this(Main, Default, IO)
+}

app/src/main/java/com/android/tvmaze/favorite/FavoriteShowState.kt

@@ -0,0 +1,12 @@
+package com.android.tvmaze.favorite
+
+import com.android.tvmaze.db.favouriteshow.FavoriteShow
+
+sealed class FavoriteShowState {
+    data class AllFavorites(val favoriteShows: List<FavoriteShow>) : FavoriteShowState()
+    data class Error(val message: String) : FavoriteShowState()
+    object Loading : FavoriteShowState()
+    object Empty : FavoriteShowState()
+    data class AddedToFavorites(val show: FavoriteShow) : FavoriteShowState()
+    data class RemovedFromFavorites(val show: FavoriteShow) : FavoriteShowState()
+}

app/src/main/java/com/android/tvmaze/favorite/FavoriteShowsActivity.kt

@@ -7,17 +7,19 @@ import android.text.SpannableString
 import android.text.Spanned
 import android.text.style.ImageSpan
 import android.view.MenuItem
-import android.view.View
 import android.widget.Toast
 import androidx.activity.viewModels
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.ContextCompat
+import androidx.core.view.isVisible
+import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.GridLayoutManager
 import com.android.tvmaze.R
 import com.android.tvmaze.databinding.ActivityFavoriteShowsBinding
 import com.android.tvmaze.db.favouriteshow.FavoriteShow
 import com.android.tvmaze.utils.GridItemDecoration
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.flow.collect
 
 @AndroidEntryPoint
 class FavoriteShowsActivity : AppCompatActivity(), FavoriteShowsAdapter.Callback {
@@ -29,8 +31,22 @@ class FavoriteShowsActivity : AppCompatActivity(), FavoriteShowsAdapter.Callback
         setContentView(binding.root)
         setToolbar()
         favoriteShowsViewModel.loadFavoriteShows()
-        favoriteShowsViewModel.getFavoriteShowsLiveData()
-            .observe(this, { showFavorites(it) })
+        lifecycleScope.launchWhenStarted {
+            favoriteShowsViewModel.favoriteShowsStateFlow.collect { setViewState(it) }
+        }
+    }
+
+    private fun setViewState(favoriteShowState: FavoriteShowState) {
+        when (favoriteShowState) {
+            is FavoriteShowState.Loading -> binding.progress.isVisible = true
+            is FavoriteShowState.AllFavorites ->
+                showFavorites(favoriteShowState.favoriteShows)
+            is FavoriteShowState.Error, FavoriteShowState.Empty -> showEmptyState()
+            is FavoriteShowState.AddedToFavorites ->
+                Toast.makeText(this, R.string.added_to_favorites, Toast.LENGTH_SHORT).show()
+            is FavoriteShowState.RemovedFromFavorites ->
+                Toast.makeText(this, R.string.removed_from_favorites, Toast.LENGTH_SHORT).show()
+        }
     }
 
     private fun setToolbar() {
@@ -43,35 +59,30 @@ class FavoriteShowsActivity : AppCompatActivity(), FavoriteShowsAdapter.Callback
     }
 
     private fun showFavorites(favoriteShows: List<FavoriteShow>) {
-        binding.progress.visibility = View.GONE
-        if (favoriteShows.isNotEmpty()) {
-            val layoutManager = GridLayoutManager(this, COLUMNS_COUNT)
-            binding.shows.layoutManager = layoutManager
-            val favoriteShowsAdapter = FavoriteShowsAdapter(favoriteShows.toMutableList(), this)
-            binding.shows.adapter = favoriteShowsAdapter
-            val spacing = resources.getDimensionPixelSize(R.dimen.show_grid_spacing)
-            binding.shows.addItemDecoration(GridItemDecoration(spacing, COLUMNS_COUNT))
-            binding.shows.visibility = View.VISIBLE
-        } else {
-            val bookmarkSpan = ImageSpan(this, R.drawable.favorite_border)
-            val spannableString = SpannableString(getString(R.string.favorite_hint_msg))
-            spannableString.setSpan(
-                bookmarkSpan, FAVORITE_ICON_START_OFFSET,
-                FAVORITE_ICON_END_OFFSET, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-            binding.favoriteHint.text = spannableString
-            binding.favoriteHint.visibility = View.VISIBLE
-        }
+        binding.progress.isVisible = false
+        val layoutManager = GridLayoutManager(this, COLUMNS_COUNT)
+        binding.shows.layoutManager = layoutManager
+        val favoriteShowsAdapter = FavoriteShowsAdapter(favoriteShows.toMutableList(), this)
+        binding.shows.adapter = favoriteShowsAdapter
+        val spacing = resources.getDimensionPixelSize(R.dimen.show_grid_spacing)
+        binding.shows.addItemDecoration(GridItemDecoration(spacing, COLUMNS_COUNT))
+        binding.shows.isVisible = true
+    }
+
+    private fun showEmptyState() {
+        binding.progress.isVisible = false
+        val bookmarkSpan = ImageSpan(this, R.drawable.favorite_border)
+        val spannableString = SpannableString(getString(R.string.favorite_hint_msg))
+        spannableString.setSpan(
+            bookmarkSpan, FAVORITE_ICON_START_OFFSET,
+            FAVORITE_ICON_END_OFFSET, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+        )
+        binding.favoriteHint.text = spannableString
+        binding.favoriteHint.isVisible = true
     }
 
     override fun onFavoriteClicked(show: FavoriteShow) {
-        if (!show.isFavorite) {
-            favoriteShowsViewModel.addToFavorite(show)
-            Toast.makeText(this, R.string.added_to_favorites, Toast.LENGTH_SHORT).show()
-        } else {
-            favoriteShowsViewModel.removeFromFavorite(show)
-            Toast.makeText(this, R.string.removed_from_favorites, Toast.LENGTH_SHORT).show()
-        }
+        favoriteShowsViewModel.onFavoriteClick(show)
     }
 
     companion object {

app/src/main/java/com/android/tvmaze/favorite/FavoriteShowsRepository.kt

@@ -3,9 +3,6 @@ package com.android.tvmaze.favorite
 import com.android.tvmaze.db.favouriteshow.FavoriteShow
 import com.android.tvmaze.db.favouriteshow.ShowDao
 import com.android.tvmaze.network.home.Show
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -17,7 +14,7 @@ constructor(private val showDao: ShowDao) {
         return showDao.allFavouriteShows()
     }
 
-    fun insertShowIntoFavorites(show: Show) {
+    suspend fun insertShowIntoFavorites(show: Show) {
         val favoriteShow = FavoriteShow(
             id = show.id,
             name = show.name,
@@ -28,10 +25,10 @@ constructor(private val showDao: ShowDao) {
             runtime = show.runtime!!,
             isFavorite = true
         )
-        CoroutineScope(Dispatchers.IO).launch { showDao.insert(favoriteShow) }
+        showDao.insert(favoriteShow)
     }
 
-    fun removeShowFromFavorites(show: Show) {
+    suspend fun removeShowFromFavorites(show: Show) {
         val favoriteShow = FavoriteShow(
             id = show.id,
             name = show.name,
@@ -42,22 +39,22 @@ constructor(private val showDao: ShowDao) {
             runtime = show.runtime!!,
             isFavorite = false
         )
-        CoroutineScope(Dispatchers.IO).launch { showDao.remove(favoriteShow) }
+        showDao.remove(favoriteShow)
     }
 
-    fun insertIntoFavorites(favoriteShow: FavoriteShow) {
-        CoroutineScope(Dispatchers.IO).launch { showDao.insert(favoriteShow) }
+    suspend fun insertIntoFavorites(favoriteShow: FavoriteShow) {
+        showDao.insert(favoriteShow)
     }
 
-    fun removeFromFavorites(favoriteShow: FavoriteShow) {
-        CoroutineScope(Dispatchers.IO).launch { showDao.remove(favoriteShow) }
+    suspend fun removeFromFavorites(favoriteShow: FavoriteShow) {
+        showDao.remove(favoriteShow)
     }
 
     suspend fun allFavoriteShowIds(): List<Long> {
         return showDao.getFavoriteShowIds()
     }
 
-    fun clearAll() {
-        CoroutineScope(Dispatchers.IO).launch { showDao.clear() }
+    suspend fun clearAll() {
+        showDao.clear()
     }
 }

app/src/main/java/com/android/tvmaze/favorite/FavoriteShowsViewModel.kt

@@ -1,21 +1,30 @@
 package com.android.tvmaze.favorite
 
 import androidx.hilt.lifecycle.ViewModelInject
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.android.tvmaze.db.favouriteshow.FavoriteShow
+import com.android.tvmaze.di.CoroutinesDispatcherProvider
 import kotlinx.coroutines.CoroutineExceptionHandler
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import timber.log.Timber
-import java.util.ArrayList
+import java.util.*
 
 class FavoriteShowsViewModel @ViewModelInject
-constructor(private val favoriteShowsRepository: FavoriteShowsRepository) : ViewModel() {
-    private val favoriteShowsLiveData: MutableLiveData<List<FavoriteShow>> = MutableLiveData()
+constructor(
+    private val favoriteShowsRepository: FavoriteShowsRepository,
+    // Inject coroutineDispatcher to facilitate Unit Testing
+    private val coroutinesDispatcherProvider: CoroutinesDispatcherProvider
+) : ViewModel() {
+    private val _favoriteShowsStateFlow =
+        MutableStateFlow<FavoriteShowState>(FavoriteShowState.Loading)
+
+    // Represents _favoriteShowsStateFlow mutable state flow as a read-only state flow.
+    val favoriteShowsStateFlow = _favoriteShowsStateFlow.asStateFlow()
+
     private lateinit var removedFromFavoriteShows: List<FavoriteShow>
 
     fun loadFavoriteShows() {
@@ -24,33 +33,35 @@ constructor(private val favoriteShowsRepository: FavoriteShowsRepository) : View
         }
 
         viewModelScope.launch(coroutineExceptionHandler) {
-            val favoriteShows = withContext(Dispatchers.IO + coroutineExceptionHandler) {
-                favoriteShowsRepository.allFavoriteShows()
-            }
-            withContext(Dispatchers.Main + coroutineExceptionHandler) {
-                onFavoritesFetched(favoriteShows)
+            val favoriteShows =
+                withContext(coroutinesDispatcherProvider.io) {
+                    favoriteShowsRepository.allFavoriteShows()
+                }
+            withContext(coroutinesDispatcherProvider.main) {
+                removedFromFavoriteShows = ArrayList(favoriteShows.size)
+                if (favoriteShows.isNotEmpty()) {
+                    _favoriteShowsStateFlow.emit(FavoriteShowState.AllFavorites(favoriteShows))
+                } else {
+                    _favoriteShowsStateFlow.emit(FavoriteShowState.Empty)
+                }
             }
         }
     }
 
     private fun onError(throwable: Throwable) {
+        _favoriteShowsStateFlow.value = FavoriteShowState.Error(throwable.localizedMessage)
         Timber.d(throwable)
     }
 
-    private fun onFavoritesFetched(favoriteShows: List<FavoriteShow>) {
-        removedFromFavoriteShows = ArrayList(favoriteShows.size)
-        favoriteShowsLiveData.value = favoriteShows
-    }
-
-    fun getFavoriteShowsLiveData(): LiveData<List<FavoriteShow>> {
-        return favoriteShowsLiveData
-    }
-
-    fun addToFavorite(show: FavoriteShow) {
-        favoriteShowsRepository.insertIntoFavorites(show)
-    }
-
-    fun removeFromFavorite(show: FavoriteShow) {
-        favoriteShowsRepository.removeFromFavorites(show)
+    fun onFavoriteClick(show: FavoriteShow) {
+        viewModelScope.launch(coroutinesDispatcherProvider.io) {
+            if (!show.isFavorite) {
+                favoriteShowsRepository.insertIntoFavorites(show)
+                _favoriteShowsStateFlow.emit(FavoriteShowState.AddedToFavorites(show))
+            } else {
+                favoriteShowsRepository.removeFromFavorites(show)
+                _favoriteShowsStateFlow.emit(FavoriteShowState.RemovedFromFavorites(show))
+            }
+        }
     }
 }