Workshop implementation, relative mouse movement toggle, and ControlsProfile binding fix

app/src/main/java/app/gamenative/ui/PluviaMain.kt

@@ -97,6 +97,7 @@ import app.gamenative.utils.UpdateChecker
 import app.gamenative.utils.UpdateInfo
 import app.gamenative.utils.UpdateInstaller
 import app.gamenative.utils.LaunchDependencies
+import app.gamenative.workshop.WorkshopManager
 import com.google.android.play.core.splitcompat.SplitCompat
 import com.winlator.container.Container
 import com.winlator.container.ContainerData
@@ -1039,6 +1040,13 @@ fun PluviaMain(
                                 openContainerConfigForAppId = null
                             }
                         },
+                        onDeleteWorkshopMods = {
+                            scope.launch {
+                                withContext(Dispatchers.IO) {
+                                    WorkshopManager.deleteWorkshopMods(context, appId)
+                                }
+                            }
+                        },
                     )
                 }
             }
@@ -1740,6 +1748,149 @@ fun preLaunchApp(
         val prefixToPath: (String) -> String = { prefix ->
             PathType.from(prefix).toAbsPath(context, gameId, SteamService.userSteamId!!.accountID)
         }
+
+        // Workshop mod sync: download subscribed mods and configure symlinks
+        if (container.isWorkshopMods) {
+            try {
+                setLoadingMessage("Checking Workshop mods...")
+                setLoadingProgress(-1f)
+                val steamClient = SteamService.instance?.steamClient
+                val steamId = SteamService.userSteamId
+                if (steamClient != null && steamId != null) {
+                    val imageFs = ImageFs.find(context)
+                    val winePrefix = imageFs.wineprefix
+                    val fetchResult = WorkshopManager.getSubscribedItems(gameId, steamClient, steamId)
+                    val items = fetchResult.items
+                    if (items.isNotEmpty()) {
+                        Timber.tag("Workshop").i("Found ${items.size} subscribed workshop items for appId=$gameId")
+                        val workshopContentDir = WorkshopManager.getWorkshopContentDir(winePrefix, gameId)
+
+                        if (fetchResult.succeeded) {
+                            WorkshopManager.cleanupUnsubscribedItems(items, workshopContentDir)
+                        } else {
+                            Timber.tag("Workshop").w(
+                                "Subscription fetch incomplete, skipping cleanup to preserve existing mods"
+                            )
+                        }
+                        val itemsToSync = WorkshopManager.getItemsNeedingSync(items, workshopContentDir)
+
+                        if (itemsToSync.isNotEmpty()) {
+                            // Check available disk space before downloading
+                            // Use 2x safety margin to account for LZMA decompression
+                            // and CKM extraction creating temp files alongside originals
+                            val requiredBytes = itemsToSync.sumOf { it.fileSizeBytes } * 2
+                            val availableBytes = workshopContentDir.usableSpace
+                            if (requiredBytes > 0 && availableBytes > 0 && requiredBytes > availableBytes) {
+                                val reqMB = String.format("%.0f", requiredBytes / 1_048_576.0)
+                                val avlMB = String.format("%.0f", availableBytes / 1_048_576.0)
+                                Timber.tag("Workshop").e(
+                                    "Insufficient disk space: need ${reqMB}MB, have ${avlMB}MB"
+                                )
+                                SnackbarManager.show(
+                                    "Not enough space for workshop mods (need ${reqMB} MB, have ${avlMB} MB)"
+                                )
+                            } else {
+                                Timber.tag("Workshop").i("Downloading ${itemsToSync.size} workshop items...")
+                                setLoadingMessage("Downloading Workshop Mods (0/${itemsToSync.size})")
+                                val licenses = SteamService.getLicensesFromDb()
+
+                                // Track item-level progress so byte callbacks can include it
+                                var currentCompleted = 0
+                                var currentTitle = itemsToSync.firstOrNull()?.title ?: ""
+
+                                val successCount = WorkshopManager.downloadItems(
+                                    items = itemsToSync,
+                                    steamClient = steamClient,
+                                    licenses = licenses,
+                                    workshopContentDir = workshopContentDir,
+                                    onItemProgress = { completed, total, title ->
+                                        currentCompleted = completed
+                                        currentTitle = title
+                                        Timber.tag("Workshop").d("Progress: $completed/$total - $title")
+                                        setLoadingMessage("Downloading Workshop Mods ($completed/$total)\n$title")
+                                    },
+                                    onBytesProgress = { downloaded, total ->
+                                        if (total > 0) {
+                                            setLoadingProgress(downloaded.toFloat() / total.toFloat())
+                                            val dlMB = String.format("%.1f", downloaded / 1_048_576.0)
+                                            val totalMB = String.format("%.1f", total / 1_048_576.0)
+                                            setLoadingMessage(
+                                                "Downloading Workshop Mods ($currentCompleted/${itemsToSync.size})\n" +
+                                                    "$currentTitle\n" +
+                                                    "${dlMB} MB / ${totalMB} MB"
+                                            )
+                                        }
+                                    },
+                                    onOverallProgress = { progress ->
+                                        Timber.tag("Workshop").d("Overall: ${(progress * 100).toInt()}%")
+                                    },
+                                )
+
+                                val failedCount = itemsToSync.size - successCount
+                                if (failedCount > 0) {
+                                    Timber.tag("Workshop").w("$failedCount workshop mod(s) failed to download")
+                                    SnackbarManager.show(
+                                        "$failedCount workshop mod(s) failed to download"
+                                    )
+                                }
+
+                                WorkshopManager.fixItemFileNames(itemsToSync, workshopContentDir)
+                            }
+                        }
+
+                        // Post-processing runs every launch (not just after downloads) so
+                        // that files from a previous broken run get fixed retroactively.
+                        // Order matters: decompress LZMA first so fixFileExtensions can
+                        // read the real magic bytes (e.g. GMAD) instead of LZMA's 0x5D.
+                        WorkshopManager.extractCkmFiles(workshopContentDir)
+                        WorkshopManager.decompressLzmaFiles(workshopContentDir)
+                        WorkshopManager.fixFileExtensions(workshopContentDir)
+
+                        WorkshopManager.updateMarkerTimestamps(items, workshopContentDir)
+
+                        setLoadingMessage("Configuring Workshop mods...")
+                        setLoadingProgress(-1f)
+                        val gameRootDir = File(SteamService.getAppDirPath(gameId))
+                        val gameName = SteamService.getAppInfoOf(gameId)?.name ?: ""
+                        WorkshopManager.configureModSymlinks(
+                            gameRootDir = gameRootDir,
+                            workshopContentDir = workshopContentDir,
+                            items = items,
+                            winePrefix = winePrefix,
+                            gameName = gameName,
+                        )
+                        Timber.tag("Workshop").i("Workshop mod sync complete for appId=$gameId")
+                    } else if (!fetchResult.succeeded) {
+                        // Fetch failed and returned no items — don't wipe existing mods.
+                        // Still configure symlinks so previously downloaded mods work offline.
+                        Timber.tag("Workshop").w(
+                            "Workshop fetch failed for appId=$gameId, preserving existing on-disk mods"
+                        )
+                        val workshopContentDir = WorkshopManager.getWorkshopContentDir(winePrefix, gameId)
+                        if (workshopContentDir.exists()) {
+                            setLoadingMessage("Configuring Workshop mods...")
+                            setLoadingProgress(-1f)
+                            val gameRootDir = File(SteamService.getAppDirPath(gameId))
+                            val gameName = SteamService.getAppInfoOf(gameId)?.name ?: ""
+                            WorkshopManager.configureModSymlinks(
+                                gameRootDir = gameRootDir,
+                                workshopContentDir = workshopContentDir,
+                                items = emptyList(),
+                                winePrefix = winePrefix,
+                                gameName = gameName,
+                            )
+                        }
+                    } else {
+                        Timber.tag("Workshop").d("No subscribed workshop items for appId=$gameId")
+                    }
+                } else {
+                    Timber.tag("Workshop").w("Steam client or Steam ID not available, skipping workshop sync")
+                }
+            } catch (e: Exception) {
+                Timber.tag("Workshop").e(e, "Workshop mod sync failed, continuing without mods")
+            }
+        }
+
         setLoadingMessage("Syncing cloud saves")
         setLoadingProgress(-1f)
         val postSyncInfo = SteamService.beginLaunchApp(

app/src/main/java/app/gamenative/ui/component/dialog/ContainerConfigDialog.kt

@@ -145,6 +145,7 @@ fun ContainerConfigDialog(
     initialConfig: ContainerData = ContainerData(),
     onDismissRequest: () -> Unit,
     onSave: (ContainerData) -> Unit,
+    onDeleteWorkshopMods: (() -> Unit)? = null,
 ) {
     if (visible) {
         val context = LocalContext.current
@@ -1127,7 +1128,7 @@ fun ContainerConfigDialog(
                                 .verticalScroll(scrollState)
                                 .weight(1f),
                         ) {
-                            if (selectedTab == 0) GeneralTabContent(state, nonzeroResolutionError, aspectResolutionError)
+                            if (selectedTab == 0) GeneralTabContent(state, nonzeroResolutionError, aspectResolutionError, onDeleteWorkshopMods)
                             if (selectedTab == 1) GraphicsTabContent(state)
                             if (selectedTab == 2) EmulationTabContent(state)
                             if (selectedTab == 3) ControllerTabContent(state, default)

app/src/main/java/app/gamenative/ui/component/dialog/ControllerTab.kt

@@ -98,6 +98,13 @@ fun ControllerTabContent(state: ContainerConfigState, default: Boolean) {
             state = config.shooterMode,
             onCheckedChange = { state.config.value = config.copy(shooterMode = it) },
         )
+        SettingsSwitch(
+            colors = settingsTileColors(),
+            title = { Text(text = stringResource(R.string.relative_mouse_movement)) },
+            subtitle = { Text(text = stringResource(R.string.relative_mouse_movement_description)) },
+            state = config.relativeMouseMovement,
+            onCheckedChange = { state.config.value = config.copy(relativeMouseMovement = it) },
+        )
         SettingsListDropdown(
             colors = settingsTileColors(),
             title = { Text(text = stringResource(R.string.external_display_input)) },

app/src/main/java/app/gamenative/ui/component/dialog/GeneralTab.kt

@@ -43,6 +43,7 @@ fun GeneralTabContent(
     state: ContainerConfigState,
     nonzeroResolutionError: String,
     aspectResolutionError: String,
+    onDeleteWorkshopMods: (() -> Unit)? = null,
 ) {
     val config = state.config.value
     val graphicsDrivers = state.graphicsDrivers.value
@@ -335,6 +336,45 @@ fun GeneralTabContent(
                 onCheckedChange = { state.config.value = config.copy(unpackFiles = it) },
             )
         }
+        SettingsSwitch(
+            colors = settingsTileColorsAlt(),
+            title = { Text(text = stringResource(R.string.workshop_mods)) },
+            subtitle = { Text(text = stringResource(R.string.workshop_mods_description)) },
+            state = config.workshopMods,
+            onCheckedChange = { state.config.value = config.copy(workshopMods = it) },
+        )
+        if (onDeleteWorkshopMods != null) {
+            var showDeleteConfirmation by rememberSaveable { mutableStateOf(false) }
+            if (showDeleteConfirmation) {
+                AlertDialog(
+                    onDismissRequest = { showDeleteConfirmation = false },
+                    title = { Text(text = stringResource(R.string.delete_workshop_mods)) },
+                    text = { Text(text = stringResource(R.string.delete_workshop_mods_confirm)) },
+                    confirmButton = {
+                        TextButton(onClick = {
+                            showDeleteConfirmation = false
+                            onDeleteWorkshopMods()
+                        }) {
+                            Text(text = stringResource(R.string.delete))
+                        }
+                    },
+                    dismissButton = {
+                        TextButton(onClick = { showDeleteConfirmation = false }) {
+                            Text(text = stringResource(R.string.cancel))
+                        }
+                    },
+                )
+            }
+            TextButton(
+                onClick = { showDeleteConfirmation = true },
+                modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.delete_workshop_mods),
+                    color = androidx.compose.material3.MaterialTheme.colorScheme.error,
+                )
+            }
+        }
         SettingsSwitch(
             colors = settingsTileColorsAlt(),
             title = { Text(text = stringResource(R.string.steam_offline_mode)) },

app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt

@@ -35,6 +35,7 @@ import app.gamenative.ui.data.GameDisplayInfo
 import app.gamenative.ui.enums.AppOptionMenuType
 import app.gamenative.utils.ContainerUtils
 import app.gamenative.utils.createPinnedShortcut
+import app.gamenative.workshop.WorkshopManager
 import com.winlator.container.ContainerData
 import java.io.File
 import kotlin.text.Charsets
@@ -785,6 +786,13 @@ abstract class BaseAppScreen {
                     saveContainerConfig(context, libraryItem, it)
                     showConfigDialog = false
                 },
+                onDeleteWorkshopMods = {
+                    uiScope.launch {
+                        withContext(Dispatchers.IO) {
+                            WorkshopManager.deleteWorkshopMods(context, libraryItem.appId)
+                        }
+                    }
+                },
             )
         }
 

app/src/main/java/app/gamenative/ui/screen/xserver/XServerScreen.kt

@@ -1657,6 +1657,9 @@ fun XServerScreen(
 
                 // Set container-level shooter mode
                 setContainerShooterMode(container.isShooterMode)
+
+                // Set relative mouse movement from container setting
+                xServerView.getxServer().setRelativeMouseMovement(container.isRelativeMouseMovement)
             }
             PluviaApp.inputControlsView = icView
 

app/src/main/java/app/gamenative/utils/ContainerUtils.kt

@@ -293,6 +293,7 @@ object ContainerUtils {
             steamOfflineMode = container.isSteamOfflineMode(),
             useLegacyDRM = container.isUseLegacyDRM(),
             unpackFiles = container.isUnpackFiles(),
+            workshopMods = container.isWorkshopMods,
             suspendPolicy = container.suspendPolicy,
             portraitMode = container.isPortraitMode,
             enableXInput = enableX,
@@ -301,6 +302,7 @@ object ContainerUtils {
             disableMouseInput = disableMouse,
             touchscreenMode = touchscreenMode,
             shooterMode = shooterMode,
+            relativeMouseMovement = container.isRelativeMouseMovement,
             gestureConfig = gestureConfig,
             externalDisplayMode = externalDisplayMode,
             externalDisplaySwap = externalDisplaySwap,
@@ -378,6 +380,7 @@ object ContainerUtils {
                 "useLegacyDRM" -> value?.let { updatedData.copy(useLegacyDRM = it as? Boolean ?: updatedData.useLegacyDRM) } ?: updatedData
                 "steamOfflineMode" -> value?.let { updatedData.copy(steamOfflineMode = it as? Boolean ?: updatedData.steamOfflineMode) } ?: updatedData
                 "unpackFiles" -> value?.let { updatedData.copy(unpackFiles = it as? Boolean ?: updatedData.unpackFiles) } ?: updatedData
+                "workshopMods" -> value?.let { updatedData.copy(workshopMods = it as? Boolean ?: updatedData.workshopMods) } ?: updatedData
                 "suspendPolicy" -> value?.let { updatedData.copy(suspendPolicy = it as? String ?: updatedData.suspendPolicy) } ?: updatedData
                 "envVars" -> value?.let { updatedData.copy(envVars = it as? String ?: updatedData.envVars) } ?: updatedData
                 "cpuList" -> value?.let { updatedData.copy(cpuList = it as? String ?: updatedData.cpuList) } ?: updatedData
@@ -464,13 +467,15 @@ object ContainerUtils {
         container.setDisableMouseInput(containerData.disableMouseInput)
         container.setTouchscreenMode(containerData.touchscreenMode)
         container.setShooterMode(containerData.shooterMode)
+        container.setRelativeMouseMovement(containerData.relativeMouseMovement)
         container.setGestureConfig(containerData.gestureConfig)
         container.setExternalDisplayMode(containerData.externalDisplayMode)
         container.setExternalDisplaySwap(containerData.externalDisplaySwap)
         container.setForceDlc(containerData.forceDlc)
         container.setSteamOfflineMode(containerData.steamOfflineMode)
         container.setUseLegacyDRM(containerData.useLegacyDRM)
         container.setUnpackFiles(containerData.unpackFiles)
+        container.setWorkshopMods(containerData.workshopMods)
         container.setSuspendPolicy(containerData.suspendPolicy)
         container.setPortraitMode(containerData.portraitMode)
         if (previousUnpackFiles != containerData.unpackFiles && containerData.unpackFiles) {

app/src/main/java/app/gamenative/workshop/WorkshopItem.kt

@@ -0,0 +1,27 @@
+package app.gamenative.workshop
+
+/**
+ * Represents a subscribed Steam Workshop item with its metadata.
+ */
+data class WorkshopItem(
+    val publishedFileId: Long,
+    val appId: Int,
+    val title: String,
+    val fileSizeBytes: Long,
+    val manifestId: Long,
+    val timeUpdated: Long,
+    val fileUrl: String = "",
+    val fileName: String = "",
+    val previewUrl: String = "",
+)
+
+/**
+ * Wraps a subscription fetch result so callers can distinguish
+ * "user has no subscriptions" from "the fetch failed (network error, timeout)".
+ * When [succeeded] is false, callers should preserve existing on-disk mods
+ * instead of cleaning up based on an unreliable empty list.
+ */
+data class WorkshopFetchResult(
+    val items: List<WorkshopItem>,
+    val succeeded: Boolean,
+)