SharedItemsViewModel: use unified state livedata

Co-authored-by: Tim Krüger <t@timkrueger.me>
Signed-off-by: Álvaro Brey <alvaro.brey@nextcloud.com>

app/src/main/java/com/nextcloud/talk/shareditems/activities/SharedItemsActivity.kt

@@ -82,14 +82,15 @@ class SharedItemsActivity : AppCompatActivity() {
         supportActionBar?.setDisplayHomeAsUpEnabled(true)
 
         viewModel = ViewModelProvider(this, viewModelFactory)[SharedItemsViewModel::class.java]
-        viewModel.initialize(userEntity, roomToken, SharedItemType.MEDIA)
 
-        viewModel.sharedItemTypes.observe(this) {
+        viewModel.viewState.observe(this) { state ->
-            initTabs(it)
+            when (state) {
+                SharedItemsViewModel.NoSharedItemsState -> {
+                    // todo
                 }
-
+                is SharedItemsViewModel.LoadedState -> {
-        viewModel.sharedItems.observe(this) {
+                    val sharedMediaItems = state.items
-            Log.d(TAG, "Items received: $it")
+                    Log.d(TAG, "Items received: $sharedMediaItems")
 
                     val showGrid = viewModel.currentItemType == SharedItemType.MEDIA
                     val layoutManager = if (showGrid) {
@@ -99,11 +100,14 @@ class SharedItemsActivity : AppCompatActivity() {
                     }
 
                     val adapter = SharedItemsAdapter(showGrid, userEntity).apply {
-                items = it.items
+                        items = sharedMediaItems.items
                     }
                     binding.imageRecycler.adapter = adapter
                     binding.imageRecycler.layoutManager = layoutManager
                 }
+                is SharedItemsViewModel.TabsLoadedState -> initTabs(state.types)
+            }
+        }
 
         binding.imageRecycler.addOnScrollListener(object : RecyclerView.OnScrollListener() {
             override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
@@ -113,6 +117,8 @@ class SharedItemsActivity : AppCompatActivity() {
                 }
             }
         })
+
+        viewModel.initialize(userEntity, roomToken, SharedItemType.MEDIA)
     }
 
     private fun initTabs(sharedItemTypes: Set<SharedItemType>) {
@@ -175,6 +181,8 @@ class SharedItemsActivity : AppCompatActivity() {
 
             override fun onTabReselected(tab: TabLayout.Tab) = Unit
         })
+
+        viewModel.loadItems(SharedItemType.MEDIA)
     }
 
     override fun onOptionsItemSelected(item: MenuItem): Boolean {

app/src/main/java/com/nextcloud/talk/shareditems/viewmodels/SharedItemsViewModel.kt

@@ -41,33 +41,33 @@ class SharedItemsViewModel @Inject constructor(
 ) :
     ViewModel() {
 
-    private val _sharedItemTypes: MutableLiveData<Set<SharedItemType>> by lazy {
-        MutableLiveData<Set<SharedItemType>>().also {
-            availableTypes()
-        }
-    }
-
-    private val _sharedItems: MutableLiveData<SharedMediaItems> by lazy {
-        MutableLiveData<SharedMediaItems>().also {
-            loadItems(_currentItemType)
-        }
-    }
-
     private lateinit var repositoryParameters: SharedItemsRepository.Parameters
     private lateinit var _currentItemType: SharedItemType
-
-    val sharedItemTypes: LiveData<Set<SharedItemType>>
-        get() = _sharedItemTypes
-
-    val sharedItems: LiveData<SharedMediaItems>
-        get() = _sharedItems
-
     val currentItemType: SharedItemType
         get() = _currentItemType
 
-    fun loadNextItems() {
+    // items
-        val currentSharedItems = sharedItems.value ?: return
+    sealed interface ViewState
+    object NoSharedItemsState : ViewState
+    open class TabsLoadedState(val types: Set<SharedItemType>) : ViewState
+    class LoadedState(types: Set<SharedItemType>, val items: SharedMediaItems) : TabsLoadedState(types)
 
+    private val _viewState: MutableLiveData<ViewState> = MutableLiveData(NoSharedItemsState)
+    val viewState: LiveData<ViewState>
+        get() = _viewState
+
+    // private val _sharedItems: MutableLiveData<SharedMediaItems> by lazy {
+    //     MutableLiveData<SharedMediaItems>().also {
+    //         loadItems(_currentItemType)
+    //     }
+    // }
+    // val sharedItems: LiveData<SharedMediaItems>
+    //     get() = _sharedItems
+
+    fun loadNextItems() {
+        when (val currentState = _viewState.value) {
+            is LoadedState -> {
+                val currentSharedItems = currentState.items
                 if (currentSharedItems.moreItemsExisting) {
                     repository.media(repositoryParameters, _currentItemType, currentSharedItems.lastSeenId)
                         ?.subscribeOn(Schedulers.io())
@@ -75,6 +75,9 @@ class SharedItemsViewModel @Inject constructor(
                         ?.subscribe(observer(_currentItemType, false))
                 }
             }
+            else -> return
+        }
+    }
 
     fun loadItems(type: SharedItemType) {
 
@@ -101,23 +104,38 @@ class SharedItemsViewModel @Inject constructor(
             }
 
             override fun onComplete() {
+                val items = newSharedItems!!
+                // todo replace initmodel with tabsloadedstate
                 if (initModel) {
-                    this@SharedItemsViewModel._sharedItems.value =
+                    setCurrentState(items)
-                        newSharedItems
                 } else {
-                    val oldItems = this@SharedItemsViewModel._sharedItems.value!!.items
+                    val state = this@SharedItemsViewModel._viewState.value as LoadedState
-                    this@SharedItemsViewModel._sharedItems.value =
+                    val oldItems = state.items.items
+                    val newItems =
                         SharedMediaItems(
                             oldItems + newSharedItems!!.items,
                             newSharedItems!!.lastSeenId,
                             newSharedItems!!.moreItemsExisting
                         )
+                    setCurrentState(newItems)
+                }
+            }
+
+            private fun setCurrentState(items: SharedMediaItems) {
+                when (val state = this@SharedItemsViewModel._viewState.value) {
+                    is TabsLoadedState -> {
+                        this@SharedItemsViewModel._viewState.value = LoadedState(
+                            state.types,
+                            items
+                        )
+                    }
+                    else -> return
                 }
             }
         }
     }
 
-    private fun availableTypes() {
+    private fun loadAvailableTypes() {
         repository.availableTypes(repositoryParameters).subscribeOn(Schedulers.io())
             ?.observeOn(AndroidSchedulers.mainThread())
             ?.subscribe(object : Observer<Set<SharedItemType>> {
@@ -135,7 +153,12 @@ class SharedItemsViewModel @Inject constructor(
                 }
 
                 override fun onComplete() {
-                    this@SharedItemsViewModel._sharedItemTypes.value = this.types
+                    val newTypes = this.types
+                    if (newTypes.isNullOrEmpty()) {
+                        this@SharedItemsViewModel._viewState.value = NoSharedItemsState
+                    } else {
+                        this@SharedItemsViewModel._viewState.value = TabsLoadedState(newTypes)
+                    }
                 }
             })
     }
@@ -149,6 +172,7 @@ class SharedItemsViewModel @Inject constructor(
             roomToken
         )
         _currentItemType = initialType
+        loadAvailableTypes()
     }
 
     companion object {