chore: Release v1.26.0-dev.26 [skip ci]

# app [1.26.0-dev.26](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.25...v1.26.0-dev.26) (2026-02-27)

### Features

* improve InstalledAppsScreen caching/perf ([#2963](https://github.com/ReVanced/revanced-manager/issues/2963)) ([323d217](323d2170ef))

app/CHANGELOG.md

@@ -1,3 +1,34 @@
+# app [1.26.0-dev.26](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.25...v1.26.0-dev.26) (2026-02-27)
+
+
+### Features
+
+* improve InstalledAppsScreen caching/perf ([#2963](https://github.com/ReVanced/revanced-manager/issues/2963)) ([323d217](https://github.com/ReVanced/revanced-manager/commit/323d2170efa0e3f2c8d2245ff08a2e92c52cb9d7))
+
+# app [1.26.0-dev.25](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.24...v1.26.0-dev.25) (2026-02-27)
+
+
+### Features
+
+* improve AppSelectorScreen caching/perf ([#2961](https://github.com/ReVanced/revanced-manager/issues/2961)) ([81e5a93](https://github.com/ReVanced/revanced-manager/commit/81e5a9315db4c858fa29163d15457af97163967a))
+
+# app [1.26.0-dev.24](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.23...v1.26.0-dev.24) (2026-02-27)
+
+
+### Bug Fixes
+
+* Incorrect patcher string value ([f19080a](https://github.com/ReVanced/revanced-manager/commit/f19080a9862be4600860b67cd981b9a3a56b21e7))
+* Never show again toggle doing nothing for Update dialog ([6f4219c](https://github.com/ReVanced/revanced-manager/commit/6f4219c01ba43b70e130f210c8d48978a6056f68))
+* Release builds not working ([00b3c59](https://github.com/ReVanced/revanced-manager/commit/00b3c59572760993f69f2663456237faafff0283))
+* Remove quotes from strings ([fc30ba5](https://github.com/ReVanced/revanced-manager/commit/fc30ba5e83f27329b05dc81f484bb8f7471b6a99))
+* we actually don't want to exclude reflection symbols ([3222840](https://github.com/ReVanced/revanced-manager/commit/32228404c4ef38bb8931d5cfdf6a7aefde23a89c))
+
+
+### Features
+
+* Add announcements ([#2948](https://github.com/ReVanced/revanced-manager/issues/2948)) ([813df46](https://github.com/ReVanced/revanced-manager/commit/813df46847620bd854dccc52ff244388b3385e17))
+* Update to Patcher v22 ([#2939](https://github.com/ReVanced/revanced-manager/issues/2939)) ([8667051](https://github.com/ReVanced/revanced-manager/commit/8667051283f934a32ac7b7cc76178397dc45a0e6))
+
 # app [1.26.0-dev.23](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.22...v1.26.0-dev.23) (2026-02-19)
 
 

app/gradle.properties

@@ -1 +1 @@
-version = 1.26.0-dev.23
+version = 1.26.0-dev.26

app/src/main/java/app/revanced/manager/ui/screen/AppSelectorScreen.kt

@@ -24,9 +24,9 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberTopAppBarState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -68,20 +68,11 @@ fun AppSelectorScreen(
             uri?.let(vm::handleStorageResult)
         }
 
-    val suggestedVersions by vm.suggestedAppVersions.collectAsStateWithLifecycle(emptyMap())
+    val suggestedVersions by vm.suggestedAppVersions.collectAsStateWithLifecycle()
 
-    var filterText by rememberSaveable { mutableStateOf("") }
     var search by rememberSaveable { mutableStateOf(false) }
-
-    val appList by vm.appList.collectAsStateWithLifecycle(initialValue = emptyList())
-    val filteredAppList = remember(appList, filterText) {
-        appList.filter { app ->
-            (vm.loadLabel(app.packageInfo)).contains(
-                filterText,
-                true
-            ) or app.packageName.contains(filterText, true)
-        }
-    }
+    val appList by vm.apps.collectAsStateWithLifecycle()
+    val appsListFiltered by vm.filteredApps.collectAsStateWithLifecycle()
 
     vm.nonSuggestedVersionDialogSubject?.let {
         NonSuggestedVersionDialog(
@@ -90,17 +81,20 @@ fun AppSelectorScreen(
         )
     }
 
-    if (search)
+    if (search) {
+        val filterText by vm.filterText.collectAsState()
+
         SearchView(
             query = filterText,
-            onQueryChange = { filterText = it },
+            onQueryChange = vm::setFilterText,
             onActiveChange = { search = it },
             placeholder = { Text(stringResource(R.string.search_apps)) }
         ) {
-            if (appList.isNotEmpty() && filterText.isNotEmpty()) {
+            val appsFiltered = appsListFiltered
+            if (!appsFiltered.isNullOrEmpty() && filterText.isNotEmpty()) {
                 LazyColumnWithScrollbar(modifier = Modifier.fillMaxSize()) {
                     items(
-                        items = filteredAppList,
+                        items = appsFiltered,
                         key = { it.packageName }
                     ) { app ->
                         ListItem(
@@ -109,9 +103,9 @@ fun AppSelectorScreen(
                             },
                             leadingContent = {
                                 AppIcon(
-                                    app.packageInfo,
-                                    null,
-                                    Modifier.size(36.dp)
+                                    packageInfo = app.packageInfo,
+                                    contentDescription = null,
+                                    modifier = Modifier.size(36.dp)
                                 )
                             },
                             headlineContent = { AppLabel(app.packageInfo) },
@@ -152,6 +146,7 @@ fun AppSelectorScreen(
                 }
             }
         }
+    }
 
     val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
 
@@ -198,16 +193,33 @@ fun AppSelectorScreen(
                 HorizontalDivider()
             }
 
-            if (appList.isNotEmpty()) {
+            val apps = appList
+            if (apps == null) {
+                item(key = "LOADING") {
+                    Box(
+                        modifier = Modifier.fillParentMaxSize(),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        LoadingIndicator()
+                    }
+                }
+            } else if (apps.isNotEmpty()) {
                 items(
-                    items = appList,
-                    key = { it.packageName }
+                    items = apps,
+                    key = { "APP-" + it.packageName },
+                    contentType = { "APP" },
                 ) { app ->
                     ListItem(
                         modifier = Modifier.clickable {
                             onSelect(app.packageName)
                         },
-                        leadingContent = { AppIcon(app.packageInfo, null, Modifier.size(36.dp)) },
+                        leadingContent = {
+                            AppIcon(
+                                packageInfo = app.packageInfo,
+                                contentDescription = null,
+                                modifier = Modifier.size(36.dp)
+                            )
+                        },
                         headlineContent = {
                             AppLabel(
                                 app.packageInfo,
@@ -231,15 +243,6 @@ fun AppSelectorScreen(
                             }
                         }
                     )
-
-                }
-            } else {
-                item {
-                    Box(
-                        modifier = Modifier.fillParentMaxSize(), contentAlignment = Alignment.Center
-                    ) {
-                        LoadingIndicator()
-                    }
                 }
             }
         }

app/src/main/java/app/revanced/manager/ui/screen/InstalledAppsScreen.kt

@@ -10,6 +10,7 @@ import androidx.compose.material3.ListItem
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -30,7 +31,7 @@ fun InstalledAppsScreen(
     onAppClick: (InstalledApp) -> Unit,
     viewModel: InstalledAppsViewModel = koinViewModel()
 ) {
-    val installedApps by viewModel.apps.collectAsStateWithLifecycle(initialValue = null)
+    val installedApps by viewModel.apps.collectAsStateWithLifecycle()
 
     Column {
         LazyColumnWithScrollbar(
@@ -38,38 +39,40 @@ fun InstalledAppsScreen(
             horizontalAlignment = Alignment.CenterHorizontally,
             verticalArrangement = if (installedApps.isNullOrEmpty()) Arrangement.Center else Arrangement.Top,
         ) {
-            installedApps?.let { installedApps ->
-                if (installedApps.isNotEmpty()) {
-                    items(
-                        installedApps,
-                        key = { it.currentPackageName }
-                    ) { installedApp ->
-                        viewModel.packageInfoMap[installedApp.currentPackageName].let { packageInfo ->
-                            ListItem(
-                                modifier = Modifier.clickable { onAppClick(installedApp) },
-                                leadingContent = {
-                                    AppIcon(
-                                        packageInfo,
-                                        contentDescription = null,
-                                        Modifier.size(36.dp)
-                                    )
-                                },
-                                headlineContent = { AppLabel(packageInfo, defaultText = null) },
-                                supportingContent = { Text(installedApp.currentPackageName) }
-                            )
-
-                        }
-                    }
-                } else {
-                    item {
-                        Text(
-                            text = stringResource(R.string.no_patched_apps_found),
-                            style = MaterialTheme.typography.titleLarge
-                        )
-                    }
+            val apps = installedApps
+            if (apps == null) {
+                item(key = "LOADING") {
+                    LoadingIndicator()
                 }
+            } else if (apps.isNotEmpty()) {
+                items(
+                    apps,
+                    key = { "APP-" + it.currentPackageName },
+                    contentType = { "APP" },
+                ) { installedApp ->
+                    val packageInfo = viewModel.packageInfoMap[installedApp.currentPackageName]
 
-            } ?: item { LoadingIndicator() }
+                    ListItem(
+                        modifier = Modifier.clickable { onAppClick(installedApp) },
+                        leadingContent = {
+                            AppIcon(
+                                packageInfo,
+                                contentDescription = null,
+                                Modifier.size(36.dp)
+                            )
+                        },
+                        headlineContent = { AppLabel(packageInfo, defaultText = null) },
+                        supportingContent = { Text(installedApp.currentPackageName) }
+                    )
+                }
+            } else {
+                item(key = "NONE") {
+                    Text(
+                        text = stringResource(R.string.no_patched_apps_found),
+                        style = MaterialTheme.typography.titleLarge
+                    )
+                }
+            }
         }
     }
 }

app/src/main/java/app/revanced/manager/ui/viewmodel/AppSelectorViewModel.kt

@@ -19,8 +19,12 @@ import app.revanced.manager.util.PM
 import app.revanced.manager.util.toast
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.io.File
@@ -40,16 +44,51 @@ class AppSelectorViewModel(
             "input.apk"
         ).also(File::delete)
     }
-    val appList = pm.appList
+
+    val filterTextFlow = MutableStateFlow("")
+    val filterText: StateFlow<String> = filterTextFlow
+
+    val apps = pm.appList.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(),
+        initialValue = null,
+    )
+
+    val filteredApps = filterText
+        .combine(apps) { filter, apps ->
+            if (apps == null || filter.isBlank()) {
+                apps
+            } else {
+                apps.filter { app ->
+                    app.packageName.contains(filter, true) ||
+                            loadLabel(app.packageInfo).contains(filter)
+                }
+            }
+        }.stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(
+                stopTimeoutMillis = 0,
+                replayExpirationMillis = 10_000,
+            ),
+            initialValue = null,
+        )
 
     private val storageSelectionChannel = Channel<SelectedApp.Local>()
     val storageSelectionFlow = storageSelectionChannel.receiveAsFlow()
 
-    val suggestedAppVersions = patchBundleRepository.suggestedVersions.flowOn(Dispatchers.Default)
+    val suggestedAppVersions = patchBundleRepository.suggestedVersions.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(),
+        initialValue = emptyMap(),
+    )
 
     var nonSuggestedVersionDialogSubject by mutableStateOf<SelectedApp.Local?>(null)
         private set
 
+    fun setFilterText(filter: String) {
+        filterTextFlow.value = filter
+    }
+
     fun loadLabel(app: PackageInfo?) = with(pm) { app?.label() ?: "Not installed" }
 
     fun dismissNonSuggestedVersionDialog() {

app/src/main/java/app/revanced/manager/ui/viewmodel/InstalledAppsViewModel.kt

@@ -5,13 +5,16 @@ import androidx.compose.runtime.mutableStateMapOf
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import app.revanced.manager.data.room.apps.installed.InstallType
-import app.revanced.manager.domain.installer.RootServiceException
+import app.revanced.manager.data.room.apps.installed.InstalledApp
 import app.revanced.manager.domain.installer.RootInstaller
+import app.revanced.manager.domain.installer.RootServiceException
 import app.revanced.manager.domain.repository.InstalledAppRepository
 import app.revanced.manager.util.PM
-import app.revanced.manager.util.collectEach
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
@@ -20,32 +23,42 @@ class InstalledAppsViewModel(
     private val pm: PM,
     private val rootInstaller: RootInstaller
 ) : ViewModel() {
-    val apps = installedAppsRepository.getAll().flowOn(Dispatchers.IO)
+    val apps = installedAppsRepository.getAll()
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(),
+            initialValue = null,
+        )
 
     val packageInfoMap = mutableStateMapOf<String, PackageInfo?>()
 
     init {
         viewModelScope.launch {
-            apps.collectEach { installedApp ->
-                packageInfoMap[installedApp.currentPackageName] = withContext(Dispatchers.IO) {
-                    try {
-                        if (
-                            installedApp.installType == InstallType.MOUNT && !rootInstaller.isAppInstalled(installedApp.currentPackageName)
-                        ) {
-                            installedAppsRepository.delete(installedApp)
-                            return@withContext null
-                        }
-                    } catch (_: RootServiceException) {  }
+            apps.filterNotNull().collectLatest(::fetchPackageInfos)
+        }
+    }
 
-                    val packageInfo = pm.getPackageInfo(installedApp.currentPackageName)
-
-                    if (packageInfo == null && installedApp.installType != InstallType.MOUNT) {
-                        installedAppsRepository.delete(installedApp)
+    private suspend fun fetchPackageInfos(apps: List<InstalledApp>) {
+        for (app in apps) {
+            packageInfoMap[app.currentPackageName] = withContext(Dispatchers.IO) {
+                try {
+                    if (app.installType == InstallType.MOUNT &&
+                        !rootInstaller.isAppInstalled(app.currentPackageName)
+                    ) {
+                        installedAppsRepository.delete(app)
                         return@withContext null
                     }
-
-                    packageInfo
+                } catch (_: RootServiceException) {
                 }
+
+                val packageInfo = pm.getPackageInfo(app.currentPackageName)
+
+                if (packageInfo == null && app.installType != InstallType.MOUNT) {
+                    installedAppsRepository.delete(app)
+                    return@withContext null
+                }
+
+                packageInfo
             }
         }
     }