feat: Improve root installation

app/CHANGELOG.md

@@ -1,10 +1,3 @@
-# app [1.26.0-dev.14](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.13...v1.26.0-dev.14) (2025-12-28)
-
-
-### Bug Fixes
-
-* Update selected patch count when SelectionState changes ([#2896](https://github.com/ReVanced/revanced-manager/issues/2896)) ([0d26df0](https://github.com/ReVanced/revanced-manager/commit/0d26df03f463195dae550240c7f652680763079c))
-
 # app [1.26.0-dev.13](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.12...v1.26.0-dev.13) (2025-12-17)
 
 

app/gradle.properties

@@ -1 +1 @@
-version = 1.26.0-dev.14
+version = 1.26.0-dev.13

app/src/main/java/app/revanced/manager/domain/installer/RootInstaller.kt

@@ -54,7 +54,11 @@ class RootInstaller(
         await()
     }
 
-    suspend fun execute(vararg commands: String) = getShell().newJob().add(*commands).exec()
+    suspend fun execute(vararg commands: String): Shell.Result {
+        val stdout = mutableListOf<String>()
+        val stderr = mutableListOf<String>()
+        return getShell().newJob().add(*commands).to(stdout, stderr).exec()
+    }
 
     fun hasRootAccess() = Shell.isAppGrantedRoot() ?: false
 
@@ -108,20 +112,15 @@ class RootInstaller(
         unmount(packageName)
 
         stockAPK?.let { stockApp ->
-            pm.getPackageInfo(packageName)?.let { packageInfo ->
-                // TODO: get user id programmatically
-                if (pm.getVersionCode(packageInfo) <= pm.getVersionCode(
-                        pm.getPackageInfo(patchedAPK)
-                            ?: error("Failed to get package info for patched app")
-                    )
-                )
-                    execute("pm uninstall -k --user 0 $packageName").assertSuccess("Failed to uninstall stock app")
-            }
+            // TODO: get user id programmatically
+            execute("pm uninstall -k --user 0 $packageName")
 
-            execute("pm install \"${stockApp.absolutePath}\"").assertSuccess("Failed to install stock app")
+            execute("pm install -r -d --user 0 \"${stockApp.absolutePath}\"")
+                .assertSuccess("Failed to install stock app")
         }
 
-        remoteFS.getFile(modulePath).mkdir()
+        remoteFS.getFile(modulePath).mkdirs()
+            .also { if (!it) throw Exception("Failed to create module directory") }
 
         listOf(
             "service.sh",
@@ -142,7 +141,6 @@ class RootInstaller(
         }
 
         "$modulePath/$packageName.apk".let { apkPath ->
-
             remoteFS.getFile(patchedAPK.absolutePath)
                 .also { if (!it.exists()) throw Exception("File doesn't exist") }
                 .newInputStream().use { inputStream ->
@@ -173,9 +171,43 @@ class RootInstaller(
         const val modulesPath = "/data/adb/modules"
 
         private fun Shell.Result.assertSuccess(errorMessage: String) {
-            if (!isSuccess) throw Exception(errorMessage)
+            if (!isSuccess) {
+                throw ShellCommandException(
+                    errorMessage,
+                    code,
+                    out,
+                    err
+                )
+            }
         }
     }
 }
 
+class ShellCommandException(
+    val userMessage: String,
+    val exitCode: Int,
+    val stdout: List<String>,
+    val stderr: List<String>
+) : Exception(format(userMessage, exitCode, stdout, stderr)) {
+    companion object {
+        private fun format(message: String, exitCode: Int, stdout: List<String>, stderr: List<String>): String =
+            buildString {
+                appendLine(message)
+                appendLine("Exit code: $exitCode")
+
+                val output = stdout.filter { it.isNotBlank() }
+                val errors = stderr.filter { it.isNotBlank() }
+
+                if (output.isNotEmpty()) {
+                    appendLine("stdout:")
+                    output.forEach(::appendLine)
+                }
+                if (errors.isNotEmpty()) {
+                    appendLine("stderr:")
+                    errors.forEach(::appendLine)
+                }
+            }
+    }
+}
+
 class RootServiceException : Exception("Root not available")

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

@@ -25,7 +25,6 @@ import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberTopAppBarState
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
@@ -77,12 +76,12 @@ fun SelectedAppInfoScreen(
     val bundles by vm.bundleInfoFlow.collectAsStateWithLifecycle(emptyList())
 
     val allowIncompatiblePatches by vm.prefs.disablePatchVersionCompatCheck.getAsState()
-    val patches by remember {
-        derivedStateOf {
-            vm.getPatches(bundles, allowIncompatiblePatches)
-        }
+    val patches = remember(bundles, allowIncompatiblePatches) {
+        vm.getPatches(bundles, allowIncompatiblePatches)
+    }
+    val selectedPatchCount = remember(patches) {
+        patches.values.sumOf { it.size }
     }
-    val selectedPatchCount = patches.values.sumOf { it.size }
 
     val launcher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.StartActivityForResult(),

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

@@ -377,22 +377,22 @@ class PatcherViewModel(
         try {
             isInstalling = true
 
-            val currentPackageInfo = pm.getPackageInfo(outputFile)
-                ?: throw Exception("Failed to load application info")
-
-            // If the app is currently installed
-            val existingPackageInfo = pm.getPackageInfo(currentPackageInfo.packageName)
-            if (existingPackageInfo != null) {
-                // Check if the app version is less than the installed version
-                if (pm.getVersionCode(currentPackageInfo) < pm.getVersionCode(existingPackageInfo)) {
-                    // Exit if the selected app version is less than the installed version
-                    packageInstallerStatus = PackageInstaller.STATUS_FAILURE_CONFLICT
-                    return@launch
-                }
-            }
-
             when (installType) {
                 InstallType.DEFAULT -> {
+                    val currentPackageInfo = pm.getPackageInfo(outputFile)
+                        ?: throw Exception("Failed to load application info")
+
+                    // If the app is currently installed
+                    val existingPackageInfo = pm.getPackageInfo(currentPackageInfo.packageName)
+                    if (existingPackageInfo != null) {
+                        // Check if the app version is less than the installed version
+                        if (pm.getVersionCode(currentPackageInfo) < pm.getVersionCode(existingPackageInfo)) {
+                            // Exit if the selected app version is less than the installed version
+                            packageInstallerStatus = PackageInstaller.STATUS_FAILURE_CONFLICT
+                            return@launch
+                        }
+                    }
+
                     // Check if the app is mounted as root
                     // If it is, unmount it first, silently
                     if (rootInstaller.hasRootAccess() && rootInstaller.isAppMounted(packageName)) {
@@ -412,16 +412,6 @@ class PatcherViewModel(
                             packageInfo.label()
                         }
 
-                        // Check for base APK, first check if the app is already installed
-                        if (existingPackageInfo == null) {
-                            // If the app is not installed, check if the output file is a base apk
-                            if (currentPackageInfo.splitNames.isNotEmpty()) {
-                                // Exit if there is no base APK package
-                                packageInstallerStatus = PackageInstaller.STATUS_FAILURE_INVALID
-                                return@launch
-                            }
-                        }
-
                         val inputVersion = input.selectedApp.version
                             ?: inputFile?.let(pm::getPackageInfo)?.versionName
                             ?: throw Exception("Failed to determine input APK version")

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

@@ -8,6 +8,7 @@ import android.os.Parcelable
 import android.util.Log
 import androidx.activity.result.ActivityResult
 import androidx.annotation.StringRes
+import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -128,6 +129,8 @@ class SelectedAppInfoViewModel(
     }
 
     var options: Options by savedStateHandle.saveable {
+        val state = mutableStateOf<Options>(emptyMap())
+
         viewModelScope.launch {
             if (!persistConfiguration) return@launch // TODO: save options for patched apps.
             val bundlePatches = bundleInfoFlow.first()
@@ -138,7 +141,7 @@ class SelectedAppInfoViewModel(
             }
         }
 
-        mutableStateOf(emptyMap())
+        state
     }
         private set
 
@@ -146,6 +149,8 @@ class SelectedAppInfoViewModel(
         if (input.patches != null)
             return@saveable mutableStateOf(SelectionState.Customized(input.patches))
 
+        val selection: MutableState<SelectionState> = mutableStateOf(SelectionState.Default)
+
         // Try to get the previous selection if customization is enabled.
         viewModelScope.launch {
             if (!prefs.disableSelectionWarning.get()) return@launch
@@ -155,7 +160,7 @@ class SelectedAppInfoViewModel(
             selectionState = SelectionState.Customized(previous)
         }
 
-        mutableStateOf(SelectionState.Default)
+        selection
     }
 
     var showSourceSelector by mutableStateOf(false)
@@ -306,7 +311,7 @@ class SelectedAppInfoViewModel(
         }
     }
 
-    enum class Error(@param:StringRes val resourceId: Int) {
+    enum class Error(@StringRes val resourceId: Int) {
         NoPlugins(R.string.downloader_no_plugins_available)
     }