Refactor ReadingProgress Activity / ViewModel to use single view state

app/src/main/kotlin/me/xizzhu/android/joshua/annotated/AnnotatedVersesActivity.kt

@@ -37,7 +37,11 @@ import me.xizzhu.android.joshua.ui.listDialog
 abstract class AnnotatedVersesActivity<V : VerseAnnotation, VM : AnnotatedVersesViewModel<V>>(
     @StringRes private val toolbarText: Int
 ) : BaseActivityV2<ActivityAnnotatedBinding, AnnotatedVersesViewModel.ViewAction, AnnotatedVersesViewModel.ViewState, VM>(), BookmarkItem.Callback, HighlightItem.Callback, NoteItem.Callback, VersePreviewItem.Callback {
-    override fun inflateViewBinding(): ActivityAnnotatedBinding = ActivityAnnotatedBinding.inflate(layoutInflater)
+    override val viewBinding: ActivityAnnotatedBinding by lazy { ActivityAnnotatedBinding.inflate(layoutInflater) }
+
+    override fun initializeView() {
+        // TODO
+    }
 
     override fun onViewActionEmitted(viewAction: AnnotatedVersesViewModel.ViewAction) = when (viewAction) {
         AnnotatedVersesViewModel.ViewAction.OpenReadingScreen -> navigator.navigate(this, Navigator.SCREEN_READING, extrasForOpeningVerse())

app/src/main/kotlin/me/xizzhu/android/joshua/infra/BaseActivityV2.kt

@@ -35,9 +35,9 @@ abstract class BaseActivityV2<VB : ViewBinding, ViewAction, ViewState, VM : Base
 
     protected abstract val viewModel: VM
 
-    protected lateinit var viewBinding: VB
+    protected abstract val viewBinding: VB
 
-    protected abstract fun inflateViewBinding(): VB
+    protected abstract fun initializeView()
 
     protected abstract fun onViewActionEmitted(viewAction: ViewAction)
 
@@ -48,8 +48,8 @@ abstract class BaseActivityV2<VB : ViewBinding, ViewAction, ViewState, VM : Base
         super.onCreate(savedInstanceState)
         Log.i(tag, "onCreate()")
 
-        viewBinding = inflateViewBinding()
         setContentView(viewBinding.root)
+        initializeView()
 
         viewModel.viewAction().onEach(::onViewActionEmitted).launchIn(lifecycleScope)
         viewModel.viewState().onEach(::onViewStateUpdated).launchIn(lifecycleScope)

app/src/main/kotlin/me/xizzhu/android/joshua/progress/ReadingProgressActivity.kt

@@ -16,80 +16,92 @@
 
 package me.xizzhu.android.joshua.progress
 
-import android.os.Bundle
-import android.view.View
 import androidx.activity.viewModels
-import androidx.lifecycle.lifecycleScope
+import androidx.core.view.isVisible
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.asExecutor
 import me.xizzhu.android.joshua.Navigator
 import me.xizzhu.android.joshua.R
-import me.xizzhu.android.joshua.core.VerseIndex
+import me.xizzhu.android.joshua.core.provider.CoroutineDispatcherProvider
 import me.xizzhu.android.joshua.databinding.ActivityReadingProgressBinding
-import me.xizzhu.android.joshua.infra.BaseActivity
-import me.xizzhu.android.joshua.infra.onEach
-import me.xizzhu.android.joshua.infra.onFailure
-import me.xizzhu.android.joshua.infra.onSuccess
+import me.xizzhu.android.joshua.infra.BaseActivityV2
 import me.xizzhu.android.joshua.ui.dialog
 import me.xizzhu.android.joshua.ui.fadeIn
+import javax.inject.Inject
 
 @AndroidEntryPoint
-class ReadingProgressActivity : BaseActivity<ActivityReadingProgressBinding, ReadingProgressViewModel>(), ReadingProgressDetailItem.Callback {
-    private val readingProgressViewModel: ReadingProgressViewModel by viewModels()
+class ReadingProgressActivity : BaseActivityV2<ActivityReadingProgressBinding, ReadingProgressViewModel.ViewAction, ReadingProgressViewModel.ViewState, ReadingProgressViewModel>() {
+    @Inject
+    lateinit var coroutineDispatcherProvider: CoroutineDispatcherProvider
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
+    private lateinit var readingProgressAdapter: ReadingProgressAdapter
 
-        observeSettings()
-        observeReadingProgress()
-    }
+    override val viewModel: ReadingProgressViewModel by viewModels()
 
-    private fun observeSettings() {
-        readingProgressViewModel.settings().onEach { viewBinding.readingProgressList.setSettings(it) }.launchIn(lifecycleScope)
-    }
+    override val viewBinding: ActivityReadingProgressBinding by lazy { ActivityReadingProgressBinding.inflate(layoutInflater) }
 
-    private fun observeReadingProgress() {
-        readingProgressViewModel.readingProgress()
-                .onEach(
-                        onLoading = {
-                            with(viewBinding) {
-                                loadingSpinner.fadeIn()
-                                readingProgressList.visibility = View.GONE
-                            }
-                        },
-                        onSuccess = {
-                            with(viewBinding) {
-                                readingProgressList.setItems(it.items)
-                                readingProgressList.fadeIn()
-                                loadingSpinner.visibility = View.GONE
-                            }
-                        },
-                        onFailure = {
-                            viewBinding.loadingSpinner.visibility = View.GONE
-                            dialog(false, R.string.dialog_title_error, R.string.dialog_message_failed_to_load_reading_progress, { _, _ -> loadReadingProgress() }, { _, _ -> finish() })
-                        }
-                )
-                .launchIn(lifecycleScope)
-    }
+    override fun initializeView() {
+        readingProgressAdapter = ReadingProgressAdapter(
+            inflater = layoutInflater,
+            executor = coroutineDispatcherProvider.default.asExecutor()
+        ) { viewEvent ->
+            when (viewEvent) {
+                is ReadingProgressAdapter.ViewEvent.ExpandOrCollapseBook -> viewModel.expandOrCollapseBook(viewEvent.bookIndex)
+                is ReadingProgressAdapter.ViewEvent.OpenVerse -> viewModel.openVerse(viewEvent.verseToOpen)
+            }
+        }
 
-    override fun onStart() {
-        super.onStart()
-        loadReadingProgress()
+        with(viewBinding.readingProgressList) {
+            adapter = readingProgressAdapter
+            layoutManager = LinearLayoutManager(this@ReadingProgressActivity, RecyclerView.VERTICAL, false)
+        }
     }
 
-    private fun loadReadingProgress() {
-        readingProgressViewModel.loadReadingProgress()
+    override fun onViewActionEmitted(viewAction: ReadingProgressViewModel.ViewAction) = when (viewAction) {
+        ReadingProgressViewModel.ViewAction.OpenReadingScreen -> navigator.navigate(this, Navigator.SCREEN_READING)
     }
 
-    override fun inflateViewBinding(): ActivityReadingProgressBinding = ActivityReadingProgressBinding.inflate(layoutInflater)
+    override fun onViewStateUpdated(viewState: ReadingProgressViewModel.ViewState) = with(viewBinding) {
+        if (viewState.loading) {
+            loadingSpinner.fadeIn()
+            readingProgressList.isVisible = false
+        } else {
+            loadingSpinner.isVisible = false
+            readingProgressList.fadeIn()
+        }
 
-    override fun viewModel(): ReadingProgressViewModel = readingProgressViewModel
+        readingProgressAdapter.submitList(viewState.items)
 
-    override fun openVerse(verseToOpen: VerseIndex) {
-        readingProgressViewModel.saveCurrentVerseIndex(verseToOpen)
-                .onSuccess { navigator.navigate(this, Navigator.SCREEN_READING) }
-                .onFailure { dialog(true, R.string.dialog_title_error, R.string.dialog_message_failed_to_select_verse, { _, _ -> openVerse(verseToOpen) }) }
-                .launchIn(lifecycleScope)
+        when (val error = viewState.error) {
+            is ReadingProgressViewModel.ViewState.Error.ReadingProgressLoadingError -> {
+                dialog(
+                    cancelable = false,
+                    title = R.string.dialog_title_error,
+                    message = R.string.dialog_message_failed_to_load_reading_progress,
+                    onPositive = { _, _ -> viewModel.loadReadingProgress() },
+                    onNegative = { _, _ -> finish() },
+                    onDismiss = { viewModel.markErrorAsShown(error) }
+                )
+            }
+            is ReadingProgressViewModel.ViewState.Error.VerseOpeningError -> {
+                dialog(
+                    cancelable = true,
+                    title = R.string.dialog_title_error,
+                    message = R.string.dialog_message_failed_to_select_verse,
+                    onPositive = { _, _ -> viewModel.openVerse(error.verseToOpen) },
+                    onDismiss = { viewModel.markErrorAsShown(error) }
+                )
+            }
+            null -> {
+                // Do nothing
+            }
+        }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        viewModel.loadReadingProgress()
     }
 }