feat: AppConfigPage showDisabledRule (#1319)

Author: lisonge

app/src/main/kotlin/li/songe/gkd/store/SettingsStore.kt

@@ -57,6 +57,7 @@ data class SettingsStore(
     val a11yAppGroupType: Int = appGroupType,
     val a11yScopeAppGroupType: Int = appGroupType,
     val subsExcludeAppGroupType: Int = appGroupType,
+    val showDisabledRule: Boolean = true,
 ) {
     val useA11y get() = automatorMode == AutomatorModeOption.A11yMode.value
     val useAutomation get() = automatorMode == AutomatorModeOption.AutomationMode.value

app/src/main/kotlin/li/songe/gkd/ui/AppConfigPage.kt

@@ -50,6 +50,7 @@ import li.songe.gkd.ui.component.AppNameText
 import li.songe.gkd.ui.component.BatchActionButtonGroup
 import li.songe.gkd.ui.component.EmptyText
 import li.songe.gkd.ui.component.MenuGroupCard
+import li.songe.gkd.ui.component.MenuItemCheckbox
 import li.songe.gkd.ui.component.MenuItemRadioButton
 import li.songe.gkd.ui.component.PerfIcon
 import li.songe.gkd.ui.component.PerfIconButton
@@ -94,7 +95,6 @@ fun AppConfigPage(route: AppConfigRoute) {
     val (scrollBehavior, listState) = useListScrollState(
         resetKey,
         groupSize > 0,
-        ruleSortType.value
     )
     if (focusLog != null && groupSize > 0) {
         LaunchedEffect(null) {
@@ -247,6 +247,12 @@ fun AppConfigPage(route: AppConfigRoute) {
                                         )
                                     }
                                 }
+                                MenuGroupCard(title = "筛选") {
+                                    MenuItemCheckbox(
+                                        text = "未启用",
+                                        stateFlow = vm.showDisabledRuleFlow,
+                                    )
+                                }
                             }
                         }
                     }

app/src/main/kotlin/li/songe/gkd/ui/AppConfigVm.kt

@@ -6,15 +6,20 @@ import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flattenConcat
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import li.songe.gkd.data.RawSubscription
 import li.songe.gkd.data.SubsConfig
 import li.songe.gkd.db.DbSet
 import li.songe.gkd.store.storeFlow
 import li.songe.gkd.ui.component.ShowGroupState
+import li.songe.gkd.ui.component.getActualGroupChecked
 import li.songe.gkd.ui.component.toGroupState
 import li.songe.gkd.ui.share.BaseViewModel
+import li.songe.gkd.ui.share.asMutableStateFlow
 import li.songe.gkd.util.LogUtils
 import li.songe.gkd.util.RuleSortOption
+import li.songe.gkd.util.UsedSubsEntry
 import li.songe.gkd.util.collator
 import li.songe.gkd.util.findOption
 import li.songe.gkd.util.subsItemsFlow
@@ -25,6 +30,12 @@ class AppConfigVm(val route: AppConfigRoute) : BaseViewModel() {
     val ruleSortTypeFlow = storeFlow.mapNew {
         RuleSortOption.objects.findOption(it.appRuleSort)
     }
+    val showDisabledRuleFlow = storeFlow.asMutableStateFlow(
+        getter = { it.showDisabledRule },
+        setter = {
+            storeFlow.value.copy(showDisabledRule = it)
+        }
+    )
 
     private val usedSubsIdsFlow = subsItemsFlow.mapNew { list ->
         list.filter { it.enable }.map { it.id }.sorted()
@@ -76,8 +87,77 @@ class AppConfigVm(val route: AppConfigRoute) : BaseViewModel() {
         }.filter { it.second.isNotEmpty() }
     }.stateInit(emptyList())
 
-    val subsPairsFlow = combine(
+    private val checkedGroupSetFlow = combine(
         temp1ListFlow,
+        globalSubsConfigsFlow,
+        categoryConfigsFlow,
+        appSubsConfigsFlow,
+    ) { list, globalSubsConfigs, categoryConfigs, appSubsConfigs ->
+        val checkedSet = mutableSetOf<Triple<Long, Int, Int>>()
+        list.forEach { (entry, groups) ->
+            groups.forEach { group ->
+                val subsConfig = when (group) {
+                    is RawSubscription.RawAppGroup -> appSubsConfigs
+                    is RawSubscription.RawGlobalGroup -> globalSubsConfigs
+                }.find { it.subsId == entry.subsItem.id && it.groupKey == group.key }
+                val category = when (group) {
+                    is RawSubscription.RawAppGroup -> entry.subscription.getCategory(group.name)
+                    is RawSubscription.RawGlobalGroup -> null
+                }
+                val categoryConfig = if (category != null) {
+                    categoryConfigs.find { it.subsId == entry.subsItem.id && it.categoryKey == category.key }
+                } else {
+                    null
+                }
+                val checked = getActualGroupChecked(
+                    subs = entry.subscription,
+                    group = group,
+                    appId = route.appId,
+                    subsConfig = subsConfig,
+                    categoryConfig = categoryConfig,
+                )
+                if (checked) {
+                    checkedSet.add(Triple(entry.subsItem.id, group.groupType, group.key))
+                }
+            }
+        }
+        checkedSet
+    }.stateInit(emptySet())
+
+    private val actualCheckedGroupSetFlow = MutableStateFlow(checkedGroupSetFlow.value)
+
+    init {
+        showDisabledRuleFlow.launchOnChange {
+            actualCheckedGroupSetFlow.value = checkedGroupSetFlow.value
+        }
+        checkedGroupSetFlow.launchOnChange { a ->
+            actualCheckedGroupSetFlow.update { b -> a + b }
+        }
+    }
+
+    private val temp2ListFlow = combine(
+        temp1ListFlow,
+        showDisabledRuleFlow,
+        actualCheckedGroupSetFlow,
+    ) { list, showDisabledRule, checkedSet ->
+        if (showDisabledRule) {
+            list
+        } else {
+            val newList = mutableListOf<Pair<UsedSubsEntry, List<RawSubscription.RawGroupProps>>>()
+            list.forEach { (entry, groups) ->
+                val newGroups = groups.filter { g ->
+                    checkedSet.contains(Triple(entry.subsItem.id, g.groupType, g.key))
+                }
+                if (newGroups.isNotEmpty()) {
+                    newList.add(entry to newGroups)
+                }
+            }
+            newList
+        }
+    }.stateInit(emptyList())
+
+    val subsPairsFlow = combine(
+        temp2ListFlow,
         latestLogsFlow,
         ruleSortTypeFlow
     ) { list, logs, sortType ->
@@ -115,11 +195,11 @@ class AppConfigVm(val route: AppConfigRoute) : BaseViewModel() {
     val isSelectedModeFlow = MutableStateFlow(false)
     val selectedDataSetFlow = MutableStateFlow(emptySet<ShowGroupState>())
 
-    private fun getAllSelectedDataSet() = subsPairsFlow.value.map { e ->
+    private fun getAllSelectedDataSet() = subsPairsFlow.value.flatMap { e ->
         e.second.map { g ->
             g.toGroupState(subsId = e.first.subsItem.id, appId = route.appId)
         }
-    }.flatten().toSet()
+    }.toSet()
 
     fun selectAll() {
         selectedDataSetFlow.value = getAllSelectedDataSet()

app/src/main/kotlin/li/songe/gkd/ui/component/RuleGroupCard.kt

@@ -283,6 +283,32 @@ fun RuleGroupCard(
     }
 }
 
+fun getActualGroupChecked(
+    subs: RawSubscription,
+    group: RawSubscription.RawGroupProps,
+    appId: String?,
+    subsConfig: SubsConfig?,
+    categoryConfig: CategoryConfig?,
+): Boolean {
+    if (!group.valid) return false
+    val inGlobalAppPage = appId != null && group is RawSubscription.RawGlobalGroup
+    return if (inGlobalAppPage) {
+        getGlobalGroupChecked(
+            subs,
+            ExcludeData.parse(subsConfig?.exclude),
+            group,
+            appId,
+        )
+    } else {
+        getGroupEnable(
+            group,
+            subsConfig,
+            subs.getCategory(group.name),
+            categoryConfig,
+        )
+    } ?: false
+}
+
 
 @Composable
 fun BatchActionButtonGroup(vm: ViewModel, selectedDataSet: Set<ShowGroupState>) {