add remove system app

Author: nqmgaming

app/proguard-rules.pro

@@ -26,4 +26,11 @@
 # release `full` build ever regresses to "NOT_ROOTED" while debug works, look here first.
 -keep class com.topjohnwu.superuser.** { *; }
 -keep class com.topjohnwu.superuser.internal.** { *; }
--dontwarn com.topjohnwu.superuser.**
+-dontwarn com.topjohnwu.superuser.**
+
+# Shizuku.newProcess is package-private; we reach it via reflection to run one-shot `pm`
+# commands without building a full UserService/AIDL layer. R8 would otherwise rename the
+# method and break ShizukuShellExecutor silently in release builds.
+-keepclassmembers class rikka.shizuku.Shizuku {
+    private static *** newProcess(...);
+}

app/src/full/java/app/pwhs/universalinstaller/presentation/install/controller/FullInstallerBackendFactory.kt

@@ -69,4 +69,42 @@ class FullInstallerBackendFactory : InstallerBackendFactory {
     ): BaseInstallController = RootInstallController(
         application, packageInstaller, sessionDataRepository, historyDao,
     )
+
+    /**
+     * Shells out to `pm` directly. The quoting is trivial because package names match
+     * `[A-Za-z0-9._]+` — no shell metacharacters can appear. We still verify before
+     * passing to make refactors obvious if that assumption changes.
+     */
+    override suspend fun uninstallSystemAppViaRoot(
+        packageName: String,
+        method: SystemAppMethod,
+    ): Result<String> = withContext(Dispatchers.IO) {
+        require(packageName.matches(Regex("^[A-Za-z0-9._]+$"))) {
+            "Refusing to shell out with suspicious package name: $packageName"
+        }
+        val cmd = when (method) {
+            SystemAppMethod.UninstallForUser0 -> "pm uninstall --user 0 $packageName"
+            SystemAppMethod.Disable -> "pm disable-user --user 0 $packageName"
+        }
+        runCatching {
+            val result = Shell.cmd(cmd).exec()
+            val stdout = result.out.joinToString("\n")
+            val stderr = result.err.joinToString("\n")
+            // `pm` returns non-zero on real failures AND prints a distinctive success string
+            // per subcommand. We verify both because some ROMs return 0 for soft failures
+            // like `Failure [NOT_INSTALLED_FOR_USER]`. The string token differs per command:
+            //   `pm uninstall --user 0` → "Success"
+            //   `pm disable-user --user 0` → "new state: disabled-user"
+            val successToken = when (method) {
+                SystemAppMethod.UninstallForUser0 -> "Success"
+                SystemAppMethod.Disable -> "new state: disabled"
+            }
+            if (!result.isSuccess || !stdout.contains(successToken, ignoreCase = true)) {
+                throw RuntimeException(
+                    "pm command failed: ${stdout.ifBlank { stderr }.ifBlank { "no output" }}",
+                )
+            }
+            stdout
+        }
+    }
 }

app/src/main/java/app/pwhs/universalinstaller/presentation/install/controller/InstallerBackendFactory.kt

@@ -42,4 +42,25 @@ interface InstallerBackendFactory {
         sessionDataRepository: SessionDataRepository,
         historyDao: InstallHistoryDao,
     ): BaseInstallController?
+
+    /**
+     * Shell-out wrapper for system-app removal. Ackpine's libsu plugin routes through
+     * `IPackageInstaller.uninstall` which rejects system apps with DELETE_FAILED_INTERNAL_ERROR,
+     * so for `/system` packages we bypass ackpine and call `pm` directly via the root shell.
+     *
+     * Safe to call only when [probeRootState] returned [RootState.READY]; otherwise this
+     * returns `Result.failure`. Store flavor always returns failure.
+     */
+    suspend fun uninstallSystemAppViaRoot(
+        packageName: String,
+        method: SystemAppMethod,
+    ): Result<String>
+}
+
+enum class SystemAppMethod {
+    /** `pm uninstall --user 0 <pkg>` — hides package for user 0; reversible via `cmd package install-existing`. */
+    UninstallForUser0,
+
+    /** `pm disable-user --user 0 <pkg>` — freezes package; reversible via `pm enable`. */
+    Disable,
 }

app/src/main/java/app/pwhs/universalinstaller/presentation/install/controller/ShizukuShellExecutor.kt

@@ -0,0 +1,88 @@
+package app.pwhs.universalinstaller.presentation.install.controller
+
+import android.content.pm.PackageManager
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import rikka.shizuku.Shizuku
+import timber.log.Timber
+
+/**
+ * Run privileged `pm` commands via Shizuku's `newProcess()` — same shell UID (2000) that
+ * `adb shell` runs as, so per-user uninstall and disable of system apps work without Root.
+ *
+ * Shizuku v13 moved `newProcess` to private visibility to push callers toward the
+ * UserService/AIDL pattern. A UserService would take ~100 LOC for a one-shot shell wrapper,
+ * so instead we call via reflection. If a future Shizuku release ever removes the method,
+ * [isReady] flips to false and the ViewModel routes users to the "Root required" dialog.
+ */
+object ShizukuShellExecutor {
+
+    private val newProcessMethod: java.lang.reflect.Method? = try {
+        Shizuku::class.java.getDeclaredMethod(
+            "newProcess",
+            Array<String>::class.java,
+            Array<String>::class.java,
+            String::class.java,
+        ).apply { isAccessible = true }
+    } catch (t: Throwable) {
+        Timber.w(t, "Shizuku.newProcess not reachable — Shizuku shell path disabled")
+        null
+    }
+
+    fun isReady(): Boolean {
+        if (newProcessMethod == null) return false
+        return try {
+            Shizuku.pingBinder() &&
+                !Shizuku.isPreV11() &&
+                Shizuku.checkSelfPermission() == PackageManager.PERMISSION_GRANTED
+        } catch (t: Throwable) {
+            Timber.w(t, "Shizuku readiness check failed")
+            false
+        }
+    }
+
+    /**
+     * Shells out via Shizuku's remote process. Package name is regex-validated to block
+     * shell injection — in practice the caller feeds a PackageManager-sourced string that
+     * can't contain metacharacters, but we verify anyway.
+     */
+    suspend fun uninstallSystemApp(
+        packageName: String,
+        method: SystemAppMethod,
+    ): Result<String> = withContext(Dispatchers.IO) {
+        require(packageName.matches(Regex("^[A-Za-z0-9._]+$"))) {
+            "Refusing to shell out with suspicious package name: $packageName"
+        }
+        val reflectedMethod = newProcessMethod
+            ?: return@withContext Result.failure(
+                IllegalStateException("Shizuku.newProcess unavailable on this Shizuku build"),
+            )
+        val cmd = when (method) {
+            SystemAppMethod.UninstallForUser0 -> "pm uninstall --user 0 $packageName"
+            SystemAppMethod.Disable -> "pm disable-user --user 0 $packageName"
+        }
+        runCatching {
+            val process = reflectedMethod.invoke(
+                null,
+                arrayOf("sh", "-c", cmd),
+                null,
+                null,
+            ) as Process
+            val stdout = process.inputStream.bufferedReader().use { it.readText() }
+            val stderr = process.errorStream.bufferedReader().use { it.readText() }
+            val exitCode = process.waitFor()
+            // Same token strategy as the Root path — `pm` on some ROMs returns 0 for soft
+            // failures like `Failure [NOT_INSTALLED_FOR_USER]`, so we verify both.
+            val successToken = when (method) {
+                SystemAppMethod.UninstallForUser0 -> "Success"
+                SystemAppMethod.Disable -> "new state: disabled"
+            }
+            if (exitCode != 0 || !stdout.contains(successToken, ignoreCase = true)) {
+                throw RuntimeException(
+                    "shizuku pm failed (exit=$exitCode): ${stdout.ifBlank { stderr }.ifBlank { "no output" }}",
+                )
+            }
+            stdout
+        }
+    }
+}