courses: smoother data tag view modelling (fixes #13082)

app/build.gradle

@@ -12,8 +12,8 @@ android {
         applicationId "org.ole.planet.myplanet"
         minSdk = 26
         targetSdk = 36
-        versionCode = 5358
-        versionName = "0.53.58"
+        versionCode = 5359
+        versionName = "0.53.59"
         ndkVersion = '26.3.11579264'
         vectorDrawables.useSupportLibrary = true
     }

app/src/main/java/org/ole/planet/myplanet/model/RealmTag.kt

@@ -32,6 +32,13 @@ open class RealmTag : RealmObject() {
         return name.orEmpty()
     }
 
+    fun toTag(): Tag {
+        return Tag(
+            id = this.id,
+            name = this.name
+        )
+    }
+
     companion object {
         @JvmStatic
         fun insert(mRealm: Realm, act: JsonObject) {

app/src/main/java/org/ole/planet/myplanet/ui/courses/CoursesFragment.kt

@@ -178,30 +178,7 @@ class CoursesFragment : BaseRecyclerFragment<RealmMyCourse?>(), OnCourseItemSele
     private fun loadDataAsync() {
         val hostActivity = activity ?: return
         if (hostActivity.isFinishing) return
-        viewLifecycleOwner.lifecycleScope.launch {
-            try {
-                val ratingsDeferred = async { coursesRepository.getCourseRatings(model?.id) }
-                val progressDeferred = async { coursesRepository.getCourseProgress(model?.id) }
-
-                val allCourses = coursesRepository.getAllCourses()
-                val validCourses = allCourses.filter { !it.courseTitle.isNullOrBlank() }
-
-                val myCourses = if (isMyCourseLib) {
-                    coursesRepository.getMyCourses(userModel?.id, validCourses)
-                } else {
-                    emptyList()
-                }
-
-                val map = ratingsDeferred.await()
-                val progressMap = progressDeferred.await()
-
-                viewModel.processCourses(isMyCourseLib, userModel?.id, validCourses, myCourses, map, progressMap)
-            } catch (e: CancellationException) {
-                throw e
-            } catch (e: Exception) {
-                e.printStackTrace()
-            }
-        }
+        viewModel.loadCourses(isMyCourseLib, model?.id)
     }
 
     override suspend fun getAdapter(): RecyclerView.Adapter<out RecyclerView.ViewHolder> {
@@ -211,38 +188,17 @@ class CoursesFragment : BaseRecyclerFragment<RealmMyCourse?>(), OnCourseItemSele
             userModel = userSessionManager.getUserModel()
         }
 
-        val allCourses = coursesRepository.getAllCourses()
-        val validCourses = allCourses.filter { !it.courseTitle.isNullOrBlank() }
-
-        val myCourses = if (isMyCourseLib) {
-            coursesRepository.getMyCourses(model?.id, validCourses)
-        } else {
-            emptyList()
-        }
-
-        val (map, progressMap) = coroutineScope {
-            val ratingsDeferred = async { coursesRepository.getCourseRatings(model?.id) }
-            val progressDeferred = async { coursesRepository.getCourseProgress(model?.id) }
-            Pair(ratingsDeferred.await(), progressDeferred.await())
-        }
-
-        val allCourseIds = validCourses.mapNotNull { it.courseId }
-        val tagsMap = coursesRepository.getCourseTagsBulk(allCourseIds)
-            .mapValues { entry -> entry.value.map { it.toTag() } }
-
         adapterCourses = CoursesAdapter(
             hostActivity,
-            map,
+            HashMap(),
             userModel?.isGuest() ?: true,
             isMyCourseLib
         )
 
-        adapterCourses.setTagsMap(tagsMap)
-        viewModel.processCourses(isMyCourseLib, model?.id, validCourses, myCourses, map, progressMap)
-        adapterCourses.setProgressMap(progressMap)
         adapterCourses.setListener(this@CoursesFragment)
         adapterCourses.setRatingChangeListener(this@CoursesFragment)
         enableSortButtons()
+        viewModel.loadCourses(isMyCourseLib, model?.id)
         return adapterCourses
     }
 
@@ -279,6 +235,7 @@ class CoursesFragment : BaseRecyclerFragment<RealmMyCourse?>(), OnCourseItemSele
                 val courses = state.courses
                 adapterCourses.setProgressMap(state.progressMap)
                 adapterCourses.setRatingMap(state.map)
+                adapterCourses.setTagsMap(state.tagsMap)
                 adapterCourses.submitList(courses) {
                     if (isAdded && ::selectAll.isInitialized) {
                         selectedItems?.clear()
@@ -549,18 +506,9 @@ class CoursesFragment : BaseRecyclerFragment<RealmMyCourse?>(), OnCourseItemSele
         val selectedSubject = if (spnSubject.selectedItem.toString() == "All") "" else spnSubject.selectedItem.toString()
         val tagNames = searchTags.mapNotNull { it.name }
 
-        viewLifecycleOwner.lifecycleScope.launch {
-            val userId = model?.id
-            val state = viewModel.coursesState.value
-            val (filteredCourses, map, progressMap) = withContext(dispatcherProvider.io) {
-                val courses = coursesRepository.filterCourses(searchText, selectedGrade, selectedSubject, tagNames)
-                val resolvedMap = if (state.map.isNotEmpty()) state.map else coursesRepository.getCourseRatings(userId)
-                val resolvedProgressMap = state.progressMap ?: coursesRepository.getCourseProgress(userId)
-                Triple(courses, resolvedMap, resolvedProgressMap)
-            }
-            viewModel.processCourses(isMyCourseLib, userId, filteredCourses, filteredCourses.filter { it.userId?.contains(userId) == true }, map, progressMap)
-            scrollToTop()
-        }
+        val userId = model?.id
+        viewModel.filterCourses(isMyCourseLib, userId, searchText, selectedGrade, selectedSubject, tagNames)
+        scrollToTop()
     }
 
     private fun createAlertDialog(): AlertDialog {
@@ -740,22 +688,7 @@ class CoursesFragment : BaseRecyclerFragment<RealmMyCourse?>(), OnCourseItemSele
 
     override fun onDataUpdated(table: String, update: TableDataUpdate) {
         if (table == "courses" && update.shouldRefreshUI) {
-            if (::adapterCourses.isInitialized) {
-                viewLifecycleOwner.lifecycleScope.launch {
-                    val map = coursesRepository.getCourseRatings(model?.id)
-                    val progressMap = coursesRepository.getCourseProgress(model?.id)
-                    val allCourses = coursesRepository.getAllCourses()
-                    val validCourses = allCourses.filter { !it.courseTitle.isNullOrBlank() }
-                    val myCourses = if (isMyCourseLib) {
-                        coursesRepository.getMyCourses(model?.id, validCourses)
-                    } else {
-                        emptyList()
-                    }
-                    viewModel.processCourses(isMyCourseLib, model?.id, validCourses, myCourses, map, progressMap)
-                }
-            } else {
-                loadDataAsync()
-            }
+            loadDataAsync()
         }
     }
 
@@ -792,10 +725,4 @@ class CoursesFragment : BaseRecyclerFragment<RealmMyCourse?>(), OnCourseItemSele
         )
     }
 
-    private fun RealmTag.toTag(): Tag {
-        return Tag(
-            id = this.id,
-            name = this.name
-        )
-    }
 }

app/src/main/java/org/ole/planet/myplanet/ui/courses/CoursesViewModel.kt

@@ -5,30 +5,44 @@ import com.google.gson.JsonObject
 import dagger.hilt.android.lifecycle.HiltViewModel
 import java.util.HashMap
 import javax.inject.Inject
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import org.ole.planet.myplanet.model.Course
 import org.ole.planet.myplanet.model.RealmMyCourse
+import org.ole.planet.myplanet.model.RealmTag
+import org.ole.planet.myplanet.model.Tag
+import org.ole.planet.myplanet.repository.CoursesRepository
+import org.ole.planet.myplanet.utils.DispatcherProvider
 
 data class CoursesUiState(
     val courses: List<Course> = emptyList(),
     val map: HashMap<String?, JsonObject> = HashMap(),
-    val progressMap: HashMap<String?, JsonObject>? = null
+    val progressMap: HashMap<String?, JsonObject>? = null,
+    val tagsMap: Map<String, List<Tag>> = emptyMap()
 )
 
 @HiltViewModel
-class CoursesViewModel @Inject constructor() : ViewModel() {
+class CoursesViewModel @Inject constructor(
+    private val coursesRepository: CoursesRepository,
+    private val dispatcherProvider: DispatcherProvider
+) : ViewModel() {
 
     private val _coursesState = MutableStateFlow(CoursesUiState())
     val coursesState: StateFlow<CoursesUiState> = _coursesState
 
-    fun processCourses(
+    private fun processCourses(
         isMyCourseLib: Boolean,
         userId: String?,
         validCourses: List<RealmMyCourse>,
         myCourses: List<RealmMyCourse>,
         map: HashMap<String?, JsonObject>,
-        progressMap: HashMap<String?, JsonObject>?
+        progressMap: HashMap<String?, JsonObject>?,
+        tagsMap: Map<String, List<Tag>>
     ) {
         val sortedCourseList = if (isMyCourseLib) {
             myCourses.forEach { it.isMyCourse = true }
@@ -39,7 +53,56 @@ class CoursesViewModel @Inject constructor() : ViewModel() {
         }
 
         val mappedCourses = sortedCourseList.map { it.toCourse() }
-        _coursesState.value = CoursesUiState(mappedCourses, map, progressMap)
+        _coursesState.value = CoursesUiState(mappedCourses, map, progressMap, tagsMap)
+    }
+
+    fun loadCourses(isMyCourseLib: Boolean, userId: String?) {
+        viewModelScope.launch {
+            withContext(dispatcherProvider.io) {
+                try {
+                    val allCourses = coursesRepository.getAllCourses()
+                    val validCourses = allCourses.filter { !it.courseTitle.isNullOrBlank() }
+
+                    val myCourses = if (isMyCourseLib) {
+                        coursesRepository.getMyCourses(userId, validCourses)
+                    } else {
+                        emptyList()
+                    }
+
+                    val (map, progressMap) = coroutineScope {
+                        val ratingsDeferred = async { coursesRepository.getCourseRatings(userId) }
+                        val progressDeferred = async { coursesRepository.getCourseProgress(userId) }
+                        Pair(ratingsDeferred.await(), progressDeferred.await())
+                    }
+
+                    val allCourseIds = validCourses.mapNotNull { it.courseId }
+                    val tagsMap = coursesRepository.getCourseTagsBulk(allCourseIds)
+                        .mapValues { entry -> entry.value.map { it.toTag() } }
+
+                    processCourses(isMyCourseLib, userId, validCourses, myCourses, map, progressMap, tagsMap)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+        }
+    }
+
+    fun filterCourses(isMyCourseLib: Boolean, userId: String?, searchText: String, selectedGrade: String, selectedSubject: String, tagNames: List<String>) {
+        viewModelScope.launch {
+            withContext(dispatcherProvider.io) {
+                val filteredCourses = coursesRepository.filterCourses(searchText, selectedGrade, selectedSubject, tagNames)
+                val myCourses = filteredCourses.filter { it.userId?.contains(userId) == true }
+
+                val (map, progressMap) = coroutineScope {
+                    val ratingsDeferred = async { coursesRepository.getCourseRatings(userId) }
+                    val progressDeferred = async { coursesRepository.getCourseProgress(userId) }
+                    Pair(ratingsDeferred.await(), progressDeferred.await())
+                }
+
+                val tagsMap = _coursesState.value.tagsMap
+                processCourses(isMyCourseLib, userId, filteredCourses, myCourses, map, progressMap, tagsMap)
+            }
+        }
     }
 
     private fun RealmMyCourse.toCourse(): Course {