Refactor how extensions list is modelled

To better enable changing the UI in the future based on sections.

app/src/main/java/eu/kanade/presentation/browse/ExtensionsScreen.kt

@@ -146,25 +146,15 @@ private fun ExtensionContent(
             }
         }
 
-        items(
+        state.items.forEach { (header, items) ->
-            items = state.items,
+            item(
-            contentType = {
+                contentType = "header",
-                when (it) {
+                key = "extensionHeader-${header.hashCode()}",
-                    is ExtensionUiModel.Header -> "header"
+            ) {
-                    is ExtensionUiModel.Item -> "item"
+                when (header) {
-                }
-            },
-            key = {
-                when (it) {
-                    is ExtensionUiModel.Header -> "extensionHeader-${it.hashCode()}"
-                    is ExtensionUiModel.Item -> "extension-${it.hashCode()}"
-                }
-            },
-        ) { item ->
-            when (item) {
                     is ExtensionUiModel.Header.Resource -> {
                         val action: @Composable RowScope.() -> Unit =
-                        if (item.textRes == R.string.ext_updates_pending) {
+                            if (header.textRes == R.string.ext_updates_pending) {
                                 {
                                     Button(onClick = { onClickUpdateAll() }) {
                                         Text(
@@ -179,18 +169,25 @@ private fun ExtensionContent(
                                 {}
                             }
                         ExtensionHeader(
-                        textRes = item.textRes,
+                            textRes = header.textRes,
                             modifier = Modifier.animateItemPlacement(),
                             action = action,
                         )
                     }
                     is ExtensionUiModel.Header.Text -> {
                         ExtensionHeader(
-                        text = item.text,
+                            text = header.text,
                             modifier = Modifier.animateItemPlacement(),
                         )
                     }
-                is ExtensionUiModel.Item -> {
+                }
+            }
+
+            items(
+                items = items,
+                contentType = { "item" },
+                key = { "extension-${it.hashCode()}" },
+            ) { item ->
                 ExtensionItem(
                     modifier = Modifier.animateItemPlacement(),
                     item = item,
@@ -220,7 +217,6 @@ private fun ExtensionContent(
             }
         }
     }
-    }
     if (trustState != null) {
         ExtensionTrustDialog(
             onClickConfirm = {

app/src/main/java/eu/kanade/tachiyomi/ui/browse/extension/ExtensionsScreenModel.kt

@@ -40,7 +40,7 @@ class ExtensionsScreenModel(
 
     init {
         val context = Injekt.get<Application>()
-        val extensionMapper: (Map<String, InstallStep>) -> ((Extension) -> ExtensionUiModel) = { map ->
+        val extensionMapper: (Map<String, InstallStep>) -> ((Extension) -> ExtensionUiModel.Item) = { map ->
             {
                 ExtensionUiModel.Item(it, map[it.pkgName] ?: InstallStep.Idle)
             }
@@ -80,38 +80,31 @@ class ExtensionsScreenModel(
             ) { query, downloads, (_updates, _installed, _available, _untrusted) ->
                 val searchQuery = query ?: ""
 
-                val languagesWithExtensions = _available
+                val itemsGroups: ItemGroups = mutableMapOf()
-                    .filter(queryFilter(searchQuery))
-                    .groupBy { it.lang }
-                    .toSortedMap(LocaleHelper.comparator)
-                    .flatMap { (lang, exts) ->
-                        listOf(
-                            ExtensionUiModel.Header.Text(LocaleHelper.getSourceDisplayName(lang, context)),
-                            *exts.map(extensionMapper(downloads)).toTypedArray(),
-                        )
-                    }
-
-                val items = mutableListOf<ExtensionUiModel>()
 
                 val updates = _updates.filter(queryFilter(searchQuery)).map(extensionMapper(downloads))
                 if (updates.isNotEmpty()) {
-                    items.add(ExtensionUiModel.Header.Resource(R.string.ext_updates_pending))
+                    itemsGroups[ExtensionUiModel.Header.Resource(R.string.ext_updates_pending)] = updates
-                    items.addAll(updates)
                 }
 
                 val installed = _installed.filter(queryFilter(searchQuery)).map(extensionMapper(downloads))
                 val untrusted = _untrusted.filter(queryFilter(searchQuery)).map(extensionMapper(downloads))
                 if (installed.isNotEmpty() || untrusted.isNotEmpty()) {
-                    items.add(ExtensionUiModel.Header.Resource(R.string.ext_installed))
+                    itemsGroups[ExtensionUiModel.Header.Resource(R.string.ext_installed)] = installed + untrusted
-                    items.addAll(installed)
-                    items.addAll(untrusted)
                 }
 
+                val languagesWithExtensions = _available
+                    .filter(queryFilter(searchQuery))
+                    .groupBy { it.lang }
+                    .toSortedMap(LocaleHelper.comparator)
+                    .map { (lang, exts) ->
+                        ExtensionUiModel.Header.Text(LocaleHelper.getSourceDisplayName(lang, context)) to exts.map(extensionMapper(downloads))
+                    }
                 if (languagesWithExtensions.isNotEmpty()) {
-                    items.addAll(languagesWithExtensions)
+                    itemsGroups.putAll(languagesWithExtensions)
                 }
 
-                items
+                itemsGroups
             }
                 .collectLatest {
                     mutableState.update { state ->
@@ -140,10 +133,10 @@ class ExtensionsScreenModel(
         coroutineScope.launchIO {
             with(state.value) {
                 if (isEmpty) return@launchIO
-                items
+                items.values
+                    .flatten()
                     .mapNotNull {
                         when {
-                            it !is ExtensionUiModel.Item -> null
                             it.extension !is Extension.Installed -> null
                             !it.extension.hasUpdate -> null
                             else -> it.extension
@@ -216,14 +209,16 @@ class ExtensionsScreenModel(
 data class ExtensionsState(
     val isLoading: Boolean = true,
     val isRefreshing: Boolean = false,
-    val items: List<ExtensionUiModel> = emptyList(),
+    val items: ItemGroups = mutableMapOf(),
     val updates: Int = 0,
 ) {
     val isEmpty = items.isEmpty()
 }
 
-sealed interface ExtensionUiModel {
+typealias ItemGroups = MutableMap<ExtensionUiModel.Header, List<ExtensionUiModel.Item>>
-    sealed interface Header : ExtensionUiModel {
+
+object ExtensionUiModel {
+    sealed interface Header {
         data class Resource(@StringRes val textRes: Int) : Header
         data class Text(val text: String) : Header
     }
@@ -231,5 +226,5 @@ sealed interface ExtensionUiModel {
     data class Item(
         val extension: Extension,
         val installStep: InstallStep,
-    ) : ExtensionUiModel
+    )
 }