From 33e804108f6dd54a3aa0524842087fe6e85d0474 Mon Sep 17 00:00:00 2001 From: xXJsonDeruloXx Date: Thu, 22 Oct 2026 07:39:12 -0400 Subject: [PATCH] feat: expose safe desktop mode uninstall --- .../launcher/runtime/DesktopCatalog.kt | 17 ++- .../launcher/runtime/DesktopRemoval.kt | 6 +- .../com/droiddeck/launcher/ui/DesktopPage.kt | 13 ++- .../launcher/runtime/DesktopRemovalTest.kt | 102 ++++++++++++++++++ .../launcher/ui/DesktopUninstallTest.kt | 96 +++++++++++++++++ tools/desktop-kde/README.md | 3 + 6 files changed, 230 insertions(+), 7 deletions(-) create mode 100644 app/src/test/java/com/droiddeck/launcher/runtime/DesktopRemovalTest.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/ui/DesktopUninstallTest.kt diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/DesktopCatalog.kt b/app/src/main/java/com/droiddeck/launcher/runtime/DesktopCatalog.kt index 73e6a75e9..ac1b87e7a 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/DesktopCatalog.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/DesktopCatalog.kt @@ -118,7 +118,8 @@ object DesktopCatalog { fun desktopPresent(context: Context): Boolean { val root = LinuxRuntime.rootDir(context) - return File(root, DesktopRemoval.PENDING).exists() || marker(context, DESKTOP_ID).exists() + return File(root, DesktopRemoval.PENDING).exists() || marker(context, DESKTOP_ID).exists() || + journal(root, DESKTOP_ID).exists() } fun desktopSize(context: Context): Long = DesktopRemoval.installedSize(context) @@ -126,8 +127,20 @@ object DesktopCatalog { fun cleanLegacy(context: Context, listener: LinuxRuntimeInstaller.ProgressListener? = null) = DesktopRemoval.cleanLegacy(context, listener) - fun removeDesktop(context: Context, listener: LinuxRuntimeInstaller.ProgressListener): String? = + fun removeDesktop(context: Context, listener: LinuxRuntimeInstaller.ProgressListener): String? = synchronized(installLock) { DesktopRemoval.remove(context, listener) + } + + internal fun discardDesktopInstall(context: Context) { + val entry = interrupted(context).firstOrNull { it.id == DESKTOP_ID } + val journal = journal(LinuxRuntime.rootDir(context), DESKTOP_ID) + check(!journal.exists() || journal.delete()) { "Could not clear desktop installation" } + entry?.let { + val download = downloadFile(context, it) + download.delete() + File(download.path + ".resume.properties").delete() + } + } fun install(context: Context, entry: Entry, listener: LinuxRuntimeInstaller.ProgressListener?): String? = synchronized(installLock) { installLocked(context, entry, listener) diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/DesktopRemoval.kt b/app/src/main/java/com/droiddeck/launcher/runtime/DesktopRemoval.kt index 3d031a85a..ff244e6ad 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/DesktopRemoval.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/DesktopRemoval.kt @@ -44,9 +44,10 @@ internal object DesktopRemoval { val root = LinuxRuntime.rootDir(context) val pending = File(root, PENDING) val marker = File(root, ".droiddeck-pkg-${DesktopCatalog.DESKTOP_ID}") - val version = FileUtils.readString(pending)?.trim() ?: FileUtils.readString(marker)?.trim() + val installing = DesktopCatalog.interrupted(root).firstOrNull { it.id == DesktopCatalog.DESKTOP_ID } + val version = FileUtils.readString(pending)?.trim() ?: installing?.version ?: FileUtils.readString(marker)?.trim() val versions = context.assets.open("desktop-removal/versions.txt").bufferedReader().use { it.readLines() } - check(version in versions) { context.getString(R.string.desktop_removal_unknown) } + check(version in versions && (installing == null || installing.version in versions)) { context.getString(R.string.desktop_removal_unknown) } val entries = lines(context, "kde-remove.tsv.gzip").map(DesktopFileRemoval.Entry::parse) val keep = protected(context, root) cleanLegacy(context, listener) @@ -63,6 +64,7 @@ internal object DesktopRemoval { if (!target.delete()) error("Could not remove $path") } } + DesktopCatalog.discardDesktopInstall(context) if (!pending.delete()) error("Could not finish desktop removal") Log.i("DesktopRemoval", "KDE: $result") listener.onProgress(context.getString(R.string.desktop_removed), 100) diff --git a/app/src/main/java/com/droiddeck/launcher/ui/DesktopPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/DesktopPage.kt index e1068a53c..f6ce824ea 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/DesktopPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/DesktopPage.kt @@ -52,6 +52,7 @@ import androidx.compose.runtime.key import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.produceState import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberUpdatedState import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment @@ -142,8 +143,13 @@ internal fun DesktopPage(s: FrontEndState, a: FrontEndActions, modifier: Modifie PrimaryButton(open, enabled = !s.busy, main = true, large = true, icon = Icons.Outlined.DesktopWindows, onClick = click) }, beside = { - HeroIconButton(Icons.Outlined.Storefront, stringResource(R.string.flathub_name), FlathubTeal, "desktop:flathub") { at -> openFrom(at, null, "store") } - HeroIconButton(Icons.Filled.Add, stringResource(R.string.user_apps_add), null, "desktop:add") { if (!s.busy) adding = true } + Column(verticalArrangement = Arrangement.spacedBy(10.dp)) { + Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) { + HeroIconButton(Icons.Outlined.Storefront, stringResource(R.string.flathub_name), FlathubTeal, "desktop:flathub") { at -> openFrom(at, null, "store") } + HeroIconButton(Icons.Filled.Add, stringResource(R.string.user_apps_add), null, "desktop:add") { if (!s.busy) adding = true } + } + if (s.desktopPresent) UninstallDesktop(enabled = !s.runtimeActionsBlocked, onUninstall = a.onRemoveDesktop) + } }, rows = { tab -> if (tab == SheetTab.FILES) DesktopFiles(s, a) @@ -366,6 +372,7 @@ private fun DesktopFiles(s: FrontEndState, a: FrontEndActions) { @Composable private fun UninstallDesktop(enabled: Boolean, onUninstall: () -> Unit) { + val canUninstall by rememberUpdatedState(enabled) val colors = MaterialTheme.colorScheme val label = stringResource(R.string.common_uninstall) val title = stringResource(R.string.desktop_uninstall_title) @@ -383,7 +390,7 @@ private fun UninstallDesktop(enabled: Boolean, onUninstall: () -> Unit) { Text(note, fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.stepItem(1).padding(start = 4.dp, bottom = 12.dp)) Row(horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End), modifier = Modifier.fillMaxWidth().stepItem(2)) { StepChoice(keep, enabled = open, modifier = Modifier.focusRequester(first)) { Steps.fold() } - StepChoice(label, danger = true, enabled = open) { Steps.fold(); onUninstall() } + StepChoice(label, danger = true, enabled = open && canUninstall) { Steps.fold(); onUninstall() } } }) } diff --git a/app/src/test/java/com/droiddeck/launcher/runtime/DesktopRemovalTest.kt b/app/src/test/java/com/droiddeck/launcher/runtime/DesktopRemovalTest.kt new file mode 100644 index 000000000..9184a7ff3 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/runtime/DesktopRemovalTest.kt @@ -0,0 +1,102 @@ +package com.droiddeck.launcher.runtime + +import android.content.ContextWrapper +import com.droiddeck.launcher.BuildConfig +import java.io.File +import java.nio.file.Files +import java.nio.file.Paths +import java.util.zip.GZIPInputStream +import org.junit.After +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment + +@RunWith(RobolectricTestRunner::class) +class DesktopRemovalTest { + private val dir = Files.createTempDirectory("desktop-removal").toFile() + private val context = object : ContextWrapper(RuntimeEnvironment.getApplication()) { + override fun getFilesDir() = File(dir, "files").apply { mkdirs() } + override fun getCacheDir() = File(dir, "cache").apply { mkdirs() } + } + private val root = LinuxRuntime.rootDir(context).apply { mkdirs() } + private val marker = File(root, ".droiddeck-pkg-${DesktopCatalog.DESKTOP_ID}") + private val journal = File(root, marker.name + ".installing") + private val pending = File(root, DesktopRemoval.PENDING) + private val listener = LinuxRuntimeInstaller.ProgressListener { _, _ -> } + + @After fun cleanup() { dir.deleteRecursively() } + + @Test fun removesTheDesktopWhileKeepingRuntimeAppsGamesAndSettings() { + val desktop = desktopFiles() + marker.writeText(BuildConfig.DESKTOP_KDE_TAG) + val keep = listOf("root/.local/share/Steam/steamapps/common/game/data", "root/.config/kdeglobals", + "opt/appimages/custom.AppImage", "usr/lib/shared.so", "usr/share/plasma/custom") + .map { file(it, "keep") } + + assertTrue(DesktopCatalog.desktopPresent(context)) + assertNull(DesktopCatalog.removeDesktop(context, listener)) + + assertFalse(Files.exists(desktop.toPath(), java.nio.file.LinkOption.NOFOLLOW_LINKS)) + keep.forEach { assertEquals("keep", it.readText()) } + assertFalse(DesktopCatalog.desktopPresent(context)) + assertFalse(DesktopCatalog.desktopInstalled(context)) + } + + @Test fun interruptedInstallCanBeRemovedWithoutBeingResumedAtTheNextLaunch() { + desktopFiles() + val entry = DesktopCatalog.desktopEntry(context) + journal.writeText(DesktopCatalog.entryJson(entry).toString()) + val download = File(context.cacheDir, "pkg-${entry.id}-${entry.sha256.take(12)}.download").apply { writeText("download") } + val resume = File(download.path + ".resume.properties").apply { writeText("resume") } + val unrelated = file(".droiddeck-pkg-emulators.installing", DesktopCatalog.entryJson(DesktopCatalog.Entry( + "emulators", "Emulators", 1, "1", "tar", "https://example.invalid/emulators", "a".repeat(64), 1L, "", "", "", + )).toString()) + assertTrue(DesktopCatalog.desktopPresent(context)) + + assertNotNull(DesktopCatalog.removeDesktop(context) { _, _ -> error("interrupted") }) + assertTrue(pending.exists()) + assertTrue(journal.exists()) + assertTrue(DesktopCatalog.desktopPresent(context)) + assertNull(DesktopCatalog.removeDesktop(context, listener)) + + assertFalse(journal.exists()) + assertFalse(pending.exists()) + assertFalse(download.exists()) + assertFalse(resume.exists()) + assertFalse(DesktopCatalog.desktopPresent(context)) + assertEquals(listOf("emulators"), DesktopCatalog.interrupted(context).map { it.id }) + assertTrue(unrelated.exists()) + } + + @Test fun refusesUnknownDesktopVersionsAndMissingRuntimeOwnershipBeforeDeletingAnything() { + val desktop = desktopFiles() + marker.writeText("future-desktop") + assertNotNull(DesktopCatalog.removeDesktop(context, listener)) + assertEquals("future-desktop", marker.readText()) + marker.writeText(BuildConfig.DESKTOP_KDE_TAG) + journal.writeText(DesktopCatalog.entryJson(DesktopCatalog.desktopEntry(context)).put("version", "future-desktop").toString()) + assertNotNull(DesktopCatalog.removeDesktop(context, listener)) + assertTrue(journal.exists()) + journal.delete() + File(root, "var/lib/pacman/local/base-1/files").delete() + assertNotNull(DesktopCatalog.removeDesktop(context, listener)) + assertEquals(BuildConfig.DESKTOP_KDE_TAG, marker.readText()) + assertFalse(pending.exists()) + assertTrue(Files.isSymbolicLink(desktop.toPath())) + } + + private fun file(path: String, text: String) = File(root, path).apply { parentFile!!.mkdirs(); writeText(text) } + + private fun desktopFiles(): File { + file("var/lib/pacman/local/base-1/files", "%FILES%\nusr/lib/shared.so\n") + val entry = GZIPInputStream(context.assets.open("desktop-removal/kde-remove.tsv.gzip")).bufferedReader().use { reader -> + reader.lineSequence().map(DesktopFileRemoval.Entry::parse).first { it.kind == "L" && it.path.startsWith("usr/") } + } + return File(root, entry.path).apply { + parentFile!!.mkdirs() + Files.createSymbolicLink(toPath(), Paths.get(entry.identity)) + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/DesktopUninstallTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/DesktopUninstallTest.kt new file mode 100644 index 000000000..3dd558f21 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/DesktopUninstallTest.kt @@ -0,0 +1,96 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.assertIsNotEnabled +import androidx.compose.ui.test.onAllNodesWithText +import androidx.compose.ui.test.onLast +import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.performClick +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34], qualifiers = "w1200dp-h752dp-land", application = android.app.Application::class) +class DesktopUninstallTest { + @get:Rule val compose = createRobolectricComposeRule() + private var removals = 0 + private var runtimeBlocked by mutableStateOf(false) + + @After fun closeConfirmation() { Steps.drop() } + + @Test fun uninstallIsAvailableOnTheDesktopPageAndRequiresConfirmation() { + show() + compose.onNodeWithText("Open desktop").assertIsDisplayed() + compose.onNodeWithText("Uninstall").assertIsDisplayed().performClick() + settle() + assertEquals(0, removals) + compose.onNodeWithText("Uninstall the desktop?").assertIsDisplayed() + compose.onAllNodesWithText("Uninstall").onLast().performClick() + assertEquals(1, removals) + } + + @Test fun uninstallIsDisabledWhileRuntimeChangesAreBlocked() { + show(blocked = true) + compose.onNodeWithText("Uninstall").assertIsNotEnabled() + } + + @Test fun aPartialDesktopStillOffersUninstall() { + show(installed = false) + compose.onNodeWithText("Uninstall").assertIsDisplayed() + } + + @Test fun startingRuntimeWorkWhileConfirmingDisablesUninstall() { + show() + compose.onNodeWithText("Uninstall").performClick() + settle() + compose.runOnIdle { runtimeBlocked = true } + settle() + compose.onAllNodesWithText("Uninstall").onLast().assertIsNotEnabled() + assertEquals(0, removals) + } + + private fun settle() = compose.mainClock.advanceTimeBy(2_000) + + private fun show(installed: Boolean = true, blocked: Boolean = false) { + runtimeBlocked = blocked + compose.mainClock.autoAdvance = false + compose.setContent { + DroidDeckTheme { + CompositionLocalProvider(LocalFrontFocus provides FrontFocus()) { + FocusGlideHost { + Box(Modifier.fillMaxSize()) { + DesktopPage(FrontEndState( + installed = "r9", ready = true, available = null, busy = false, stage = "", percent = -1, + desktopInstalled = installed, desktopPresent = true, runtimeActionsBlocked = runtimeBlocked, + offlineAccount = null, offline = false, frameGenLabel = "", romsDir = null, logsEnabled = false, + steamGames = emptyList(), emulators = emptyList(), running = null, + ), FrontEndActions( + onPlay = {}, onPlayDesktopUi = {}, onSteamGame = {}, onDesktop = {}, onEmulator = {}, onRom = {}, onResume = {}, + onSteamSettings = {}, onDesktopSettings = {}, onInstallPackage = {}, onRemovePackage = {}, + onRuntime = {}, onFrameGenPick = {}, onImportLossless = {}, onProtons = {}, onComponents = {}, + onPerformance = {}, onRoms = {}, onFiles = {}, onLogs = {}, onOffline = {}, + onWirelessAdbPair = { _, _, _, _ -> }, onWirelessAdbApply = { _, _, _, _ -> }, + onSetPhantomProcessLimit = { _, _ -> }, onRemoveDesktop = { removals++ }, + ), Modifier.fillMaxSize(), onSelect = {}) + StepsLayer(Offset.Zero) + } + } + } + } + } + settle() + } +} diff --git a/tools/desktop-kde/README.md b/tools/desktop-kde/README.md index ced96147e..549651101 100644 --- a/tools/desktop-kde/README.md +++ b/tools/desktop-kde/README.md @@ -49,6 +49,9 @@ pacman files and emulator bundle paths are protected even when they overlap an a It never follows parent symlinks or recursively deletes directories. Home, added apps, custom files and modified package files stay. A pending marker disables the installed state and allows retry after interruption. Installing the desktop again repairs its package files and clears it. +Uninstall is available beside Open desktop and under Desktop → Files, including for an +interrupted installation. Successful removal clears that desktop installation's recovery record +and cached download so the next guest launch cannot reinstall it through package recovery. The old LXQt applications are cleaned after KDE installation and before the next guest launch on an already-upgraded runtime, protecting both KDE inventories as well as the runtime and emulators. Only files owned by `lxqt-applications.txt`'s application packages are candidates; dependencies