Allow for choosing which steam family library copy to use (DLCs etc)

app/src/main/java/app/gamenative/PrefManager.kt

@@ -104,6 +104,7 @@ object PrefManager {
                 pref.remove(STEAM_USER_NAME)
                 pref.remove(LAST_PICS_CHANGE_NUMBER)
                 pref.remove(STEAM_GAMES_COUNT)
+                pref.remove(PREFERRED_FAMILY_LENDERS_JSON)
             }
         }
     }
@@ -1406,4 +1407,52 @@ object PrefManager {
                 setPref(NEXUS_LAST_PLACEMENT_JSON, value)
             }
         }
+
+    /**
+     * Preferred Steam Families lender per appId (appId string → lender steamId64).
+     * Empty / missing entry means use the account's own copy when available.
+     */
+    private val PREFERRED_FAMILY_LENDERS_JSON = stringPreferencesKey("preferred_family_lenders_json")
+
+    private fun decodePreferredFamilyLenders(value: String): Map<Int, Long> =
+        runCatching {
+            Json.decodeFromString<Map<String, Long>>(value)
+                .mapNotNull { (key, lenderSteamId) ->
+                    key.toIntOrNull()?.let { appId -> appId to lenderSteamId }
+                }
+                .toMap()
+        }.getOrDefault(emptyMap())
+
+    var preferredFamilyLenders: Map<Int, Long>
+        get() = decodePreferredFamilyLenders(getPref(PREFERRED_FAMILY_LENDERS_JSON, "{}"))
+        set(value) {
+            if (value.isEmpty()) {
+                removePref(PREFERRED_FAMILY_LENDERS_JSON)
+            } else {
+                setPref(
+                    PREFERRED_FAMILY_LENDERS_JSON,
+                    Json.encodeToString(value.mapKeys { it.key.toString() }),
+                )
+            }
+        }
+
+    fun setPreferredFamilyLender(appId: Int, lenderSteamId: Long?) {
+        scope.launch {
+            dataStore.edit { pref ->
+                val current = decodePreferredFamilyLenders(pref[PREFERRED_FAMILY_LENDERS_JSON] ?: "{}")
+                val updated = current.toMutableMap()
+                if (lenderSteamId == null || lenderSteamId == 0L) {
+                    updated.remove(appId)
+                } else {
+                    updated[appId] = lenderSteamId
+                }
+                if (updated.isEmpty()) {
+                    pref.remove(PREFERRED_FAMILY_LENDERS_JSON)
+                } else {
+                    pref[PREFERRED_FAMILY_LENDERS_JSON] =
+                        Json.encodeToString(updated.mapKeys { it.key.toString() })
+                }
+            }
+        }
+    }
 }

app/src/main/java/app/gamenative/data/PreferredCopyOption.kt

@@ -0,0 +1,13 @@
+package app.gamenative.data
+
+/**
+ * One selectable Steam Families library copy for an app.
+ */
+data class PreferredCopyOption(
+    val lenderSteamId: Long,
+    val accountId: Int,
+    val displayName: String,
+    val isSelf: Boolean,
+    val packageId: Int?,
+    val ownedDlcCount: Int? = null,
+)

app/src/main/java/app/gamenative/db/dao/SteamAppDao.kt

@@ -171,6 +171,10 @@ interface SteamAppDao {
     )
     suspend fun findHiddenDLCApps(appId: Int): List<SteamApp>?
 
+    /** All local DLC rows for a parent app, regardless of license (catalog only). */
+    @Query("SELECT * FROM steam_app WHERE dlc_for_app_id = :appId")
+    suspend fun findDlcAppsForParent(appId: Int): List<SteamApp>
+
     @Query("DELETE from steam_app")
     suspend fun deleteAll()
 

app/src/main/java/app/gamenative/events/AndroidEvent.kt

@@ -24,6 +24,7 @@ interface AndroidEvent<T> : Event<T> {
     data class DownloadStatusChanged(val appId: Int, val isDownloading: Boolean) : AndroidEvent<Unit>
     data class PostInstallSyncStatusChanged(val appId: Int, val isSyncing: Boolean) : AndroidEvent<Unit>
     data class LibraryInstallStatusChanged(val appId: Int, val source: GameSource) : AndroidEvent<Unit>
+    data class PreferredCopyChanged(val appId: Int) : AndroidEvent<Unit>
     data class CustomGameImagesFetched(val appId: String) : AndroidEvent<Unit>
     data object RecommendationToggleChanged : AndroidEvent<Unit>
     data class GOGAuthCodeReceived(val authCode: String) : AndroidEvent<Unit>

app/src/main/java/app/gamenative/ui/data/GameDisplayInfo.kt

@@ -23,5 +23,10 @@ data class GameDisplayInfo(
     val compatibilityMessage: String? = null, // Compatibility message text (e.g., "Works on your GPU")
     val compatibilityColor: ULong? = null, // Compatibility message color (ARGB)
     val hltbStats: app.gamenative.utils.HltbService.Stats? = null, // How Long To Beat stats
+    /** Status line under Play for Steam Families preferred copy, e.g. "Using your copy". */
+    val preferredCopyStatusText: String? = null,
+    val showChangePreferredCopy: Boolean = false,
+    /** True while available Family library copies are being resolved off the main thread. */
+    val isLoadingPreferredCopy: Boolean = false,
 )
 

app/src/main/java/app/gamenative/ui/enums/AppOptionMenuType.kt

@@ -35,4 +35,5 @@ enum class AppOptionMenuType(@StringRes val title: Int) {
     ManageWorkshop(R.string.option_manage_workshop),
     ManageMods(R.string.option_manage_mods),
     ChangeBranch(R.string.change_branch),
+    ChangePreferredCopy(R.string.change_preferred_copy),
 }

app/src/main/java/app/gamenative/ui/model/LibraryViewModel.kt

@@ -91,6 +91,16 @@ class LibraryViewModel @Inject constructor(
         onFilterApps(paginationCurrentPage)
     }
 
+    private val onPreferredCopyChanged: (AndroidEvent.PreferredCopyChanged) -> Unit = { event ->
+        viewModelScope.launch(Dispatchers.IO) {
+            val updated = steamAppDao.findApp(event.appId) ?: return@launch
+            if (appList.any { it.id == updated.id }) {
+                appList = appList.map { if (it.id == updated.id) updated else it }
+                onFilterApps(paginationCurrentPage)
+            }
+        }
+    }
+
     private val onCustomGameImagesFetched: (AndroidEvent.CustomGameImagesFetched) -> Unit = {
         // Increment refresh counter and refresh the library list to pick up newly fetched images
         _state.update { it.copy(imageRefreshCounter = it.imageRefreshCounter + 1) }
@@ -233,6 +243,7 @@ class LibraryViewModel @Inject constructor(
         }
 
         PluviaApp.events.on<AndroidEvent.LibraryInstallStatusChanged, Unit>(onInstallStatusChanged)
+        PluviaApp.events.on<AndroidEvent.PreferredCopyChanged, Unit>(onPreferredCopyChanged)
         PluviaApp.events.on<AndroidEvent.CustomGameImagesFetched, Unit>(onCustomGameImagesFetched)
         PluviaApp.events.on<AndroidEvent.RecommendationToggleChanged, Unit>(onRecommendationToggleChanged)
 
@@ -247,6 +258,7 @@ class LibraryViewModel @Inject constructor(
     override fun onCleared() {
         searchDebounceJob?.cancel()
         PluviaApp.events.off<AndroidEvent.LibraryInstallStatusChanged, Unit>(onInstallStatusChanged)
+        PluviaApp.events.off<AndroidEvent.PreferredCopyChanged, Unit>(onPreferredCopyChanged)
         PluviaApp.events.off<AndroidEvent.CustomGameImagesFetched, Unit>(onCustomGameImagesFetched)
         PluviaApp.events.off<AndroidEvent.RecommendationToggleChanged, Unit>(onRecommendationToggleChanged)
         super.onCleared()

app/src/main/java/app/gamenative/ui/screen/library/LibraryAppScreen.kt

@@ -28,6 +28,7 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.ui.semantics.Role
 import androidx.compose.foundation.layout.displayCutout
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
@@ -61,6 +62,7 @@ import androidx.compose.material.icons.filled.Settings
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.LinearProgressIndicator
@@ -570,6 +572,7 @@ internal fun AppScreenContent(
     onUpdateClick: () -> Unit,
     onBack: () -> Unit = {},
     optionsMenu: List<AppMenuOption>,
+    onChangePreferredCopy: (() -> Unit)? = null,
 ) {
     val context = LocalContext.current
     // reactive — recomposes when network state changes
@@ -984,6 +987,51 @@ internal fun AppScreenContent(
                             }
                         }
                     }
+
+                    if (displayInfo.isLoadingPreferredCopy) {
+                        Spacer(modifier = Modifier.height(10.dp))
+                        Row(
+                            modifier = Modifier.fillMaxWidth(),
+                            verticalAlignment = Alignment.CenterVertically,
+                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                        ) {
+                            CircularProgressIndicator(
+                                modifier = Modifier.size(14.dp),
+                                strokeWidth = 2.dp,
+                                color = Color.White.copy(alpha = 0.8f),
+                            )
+                            Text(
+                                text = stringResource(R.string.loading_preferred_copy),
+                                style = MaterialTheme.typography.bodySmall,
+                                color = Color.White.copy(alpha = 0.8f),
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis,
+                            )
+                        }
+                    } else if (displayInfo.showChangePreferredCopy && onChangePreferredCopy != null) {
+                        Spacer(modifier = Modifier.height(10.dp))
+                        Column(modifier = Modifier.fillMaxWidth()) {
+                            displayInfo.preferredCopyStatusText?.let { status ->
+                                Text(
+                                    text = status,
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = Color.White.copy(alpha = 0.8f),
+                                    maxLines = 1,
+                                    overflow = TextOverflow.Ellipsis,
+                                )
+                                Spacer(modifier = Modifier.height(2.dp))
+                            }
+                            Text(
+                                text = stringResource(R.string.change_preferred_copy),
+                                style = MaterialTheme.typography.labelLarge,
+                                color = MaterialTheme.colorScheme.primary,
+                                modifier = Modifier.clickable(
+                                    role = Role.Button,
+                                    onClick = onChangePreferredCopy,
+                                ),
+                            )
+                        }
+                    }
                     }
 
                     // Compatibility status (if applicable)

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

@@ -292,6 +292,15 @@ abstract class BaseAppScreen {
         return compatibilityMessage to compatibilityColor
     }
 
+    /**
+     * Optional handler for Steam Families "Change preferred copy" under Play.
+     * Return a click lambda when the game has multiple family copies.
+     */
+    protected open fun onChangePreferredCopyClick(
+        context: Context,
+        libraryItem: LibraryItem,
+    ): (() -> Unit)? = null
+
     /**
      * Get the game display information for rendering the UI.
      * This is called to get all the data needed for the common UI layout.
@@ -1359,6 +1368,7 @@ abstract class BaseAppScreen {
             },
             onBack = onBack,
             optionsMenu = optionsMenu,
+            onChangePreferredCopy = onChangePreferredCopyClick(context, libraryItem),
         )
 
         if (showReadiness && launchActivity != null) {