Revert to the exact cold-validated tree while bisecting a Link2EA startup failure

The minimalization work after validation correlates with Link2EA dying
during services init before its IPC connect; reverting wholesale to
bisect forward with cold tests. The minimal shape is preserved on
ea-app-support-minimal.

Author: Utkarsh Dalal

app/src/main/java/app/gamenative/gamefixes/EaAppGameFix.kt

@@ -3,7 +3,10 @@ package app.gamenative.gamefixes
 import android.content.Context
 import app.gamenative.data.GameSource
 import com.winlator.container.Container
+import com.winlator.contents.ContentsManager
 import com.winlator.core.WineRegistryEditor
+import com.winlator.core.WineInfo
+import com.winlator.core.envvars.EnvVars
 import java.io.File
 import timber.log.Timber
 
@@ -28,6 +31,113 @@ private const val EA_HEADLESS_INSTALLER_RELATIVE_PATH =
 private const val EA_HEADLESS_MSI_RELATIVE_PATH =
     "__Installer/Origin/redist/internal/EAapp-wine-no-start.msi"
 
+private fun ascii(value: String) = value.toByteArray(Charsets.US_ASCII)
+
+private fun utf16Le(value: String) = value.toByteArray(Charsets.UTF_16LE)
+
+private fun replaceEqualLengthBytes(file: File, from: ByteArray, to: ByteArray): Int {
+    require(from.size == to.size)
+    if (!file.isFile) return 0
+
+    val contents = file.readBytes()
+    var replacements = 0
+    var offset = 0
+    while (offset <= contents.size - from.size) {
+        var matches = true
+        for (index in from.indices) {
+            if (contents[offset + index] != from[index]) {
+                matches = false
+                break
+            }
+        }
+        if (!matches) {
+            offset++
+            continue
+        }
+        to.copyInto(contents, offset)
+        replacements++
+        offset += from.size
+    }
+
+    if (replacements > 0) {
+        val backup = File(file.parentFile, "${file.name}.ea-gamefix-backup")
+        if (!backup.exists()) file.copyTo(backup)
+        file.writeBytes(contents)
+    }
+    return replacements
+}
+
+private fun applyEaProtonCompatibilityPatches(context: Context, container: Container) {
+    // Content identifiers include the profile revision (for example
+    // proton-11.0-1-arm64ec-1), while the extracted directory does not
+    // necessarily include it. Resolve the profile exactly as the launcher does
+    // instead of assuming that the identifier is also a directory name.
+    val contentsManager = ContentsManager(context)
+    val wineInfo = WineInfo.fromIdentifier(context, contentsManager, container.wineVersion)
+    val protonRoot = wineInfo.path
+        ?.takeIf { it.isNotBlank() }
+        ?.let(::File)
+    if (protonRoot == null || !protonRoot.isDirectory) {
+        Timber.tag("GameFixes").w(
+            "Cannot apply Sims 4 EA compatibility patches: no installed path for %s",
+            container.wineVersion,
+        )
+        return
+    }
+    Timber.tag("GameFixes").i(
+        "Applying Sims 4 EA compatibility patches to %s",
+        protonRoot.absolutePath,
+    )
+
+    // Proton's EA hook forces the Qt host through Mesa software OpenGL. Zink
+    // has no CPU device here, so Qt cannot create a pixel format at all.
+    for (path in listOf(
+        "lib/wine/x86_64-unix/ntdll.so",
+        "lib/wine/aarch64-unix/ntdll.so",
+    )) {
+        replaceEqualLengthBytes(
+            File(protonRoot, path),
+            ascii("LIBGL_ALWAYS_SOFTWARE"),
+            ascii("XIBGL_ALWAYS_SOFTWARE"),
+        )
+    }
+
+    // Proton also force-appends ANGLE Vulkan to EA's CEF subprocess. Keep the
+    // Qt host on the normal graphics path and let the per-exe compatibility
+    // configuration force the CEF helper onto its software path instead.
+    for (path in listOf(
+        "lib/wine/x86_64-windows/kernelbase.dll",
+        "lib/wine/aarch64-windows/kernelbase.dll",
+        "lib/wine/i386-windows/kernelbase.dll",
+    )) {
+        val file = File(protonRoot, path)
+        replaceEqualLengthBytes(
+            file,
+            ascii("EACefSubProcess.exe"),
+            ascii("XACefSubProcess.exe"),
+        )
+        replaceEqualLengthBytes(
+            file,
+            utf16Le("EACefSubProcess.exe"),
+            utf16Le("XACefSubProcess.exe"),
+        )
+
+        // This Proton hook forces desktop OpenGL for EA's Qt shell. Box64's
+        // Zink path exits during initialization, while EA's bundled ANGLE
+        // libraries render correctly.
+        replaceEqualLengthBytes(
+            file,
+            ascii("QT_OPENGL"),
+            ascii("XT_OPENGL"),
+        )
+        replaceEqualLengthBytes(
+            file,
+            utf16Le("QT_OPENGL"),
+            utf16Le("XT_OPENGL"),
+        )
+    }
+}
+
 private fun configureEaInstallScript(installPath: String) {
     val installScript = File(installPath, "installscript.vdf")
     if (!installScript.isFile) return
@@ -192,42 +302,6 @@ internal fun applyEaCompatibilityRegistry(container: Container, gameExeWindowsPa
     }
 }
 
-
-/**
- * A staged self-update makes EA Desktop demand a client restart mid-session,
- * which tears down any running game with it. Drop staged payloads, clear the
- * pending flag, and keep the version directory unwritable so an update can't
- * re-stage. (Remove the write protection deliberately when an EA update is
- * actually wanted.)
- */
-private fun suppressEaSelfUpdate(container: Container) {
-    val (version, _) = findInstalledEaDesktop(container) ?: return
-    val versionDir = File(container.rootDir, "$EA_DESKTOP_INSTALL_ROOT/$version")
-
-    versionDir.setWritable(true, false)
-    versionDir.listFiles()?.forEach { entry ->
-        val staged = entry.name != "EA Desktop" && entry.name != "VC" &&
-            (entry.isDirectory || entry.name.endsWith(".zip") || entry.name.endsWith(".zip.sig"))
-        if (staged) {
-            Timber.tag("GameFixes").i("Removing staged EA update: %s", entry.name)
-            entry.deleteRecursively()
-        }
-    }
-    versionDir.setWritable(false, false)
-
-    val machineIni = File(container.rootDir, ".wine/drive_c/ProgramData/EA Desktop/machine.ini")
-    if (machineIni.isFile) {
-        val lines = machineIni.readLines().map { line ->
-            when {
-                line.startsWith("machine.updatepending=") -> "machine.updatepending=0"
-                line.startsWith("machine.updateinfo=") -> "machine.updateinfo="
-                else -> line
-            }
-        }
-        machineIni.writeText(lines.joinToString("\n"))
-    }
-}
-
 const val EA_LINK2EA_LAUNCH_SCRIPT_WINDOWS_PATH =
     "C:\\\\ProgramData\\\\GameNative\\\\ea-link2ea-launch.cmd"
 
@@ -342,7 +416,14 @@ val EaAppGameFix: GameFix = object : GameFix {
         ensureHeadlessInstallerFiles(installPath)
         configureEaInstallScript(installPath)
         writeLink2EaLaunchScript(container)
-        suppressEaSelfUpdate(container)
+        container.putExtra("dnsV4MappedShim", "1")
+        applyEaProtonCompatibilityPatches(context, container)
+        val envVars = EnvVars(container.envVars)
+        if (envVars.get("QT_OPENGL") != "angle") {
+            envVars.put("QT_OPENGL", "angle")
+            container.envVars = envVars.toString()
+            container.saveData()
+        }
         val userRegFile = File(container.rootDir, ".wine/user.reg")
         if (!userRegFile.isFile) {
             userRegFile.parentFile?.mkdirs()

app/src/main/java/app/gamenative/gamefixes/GameFixesRegistry.kt

@@ -68,14 +68,9 @@ object GameFixesRegistry {
             else -> gameId
         }
         Timber.i("GameFixesRegistry: Applying fixes for game: $source $catalogId if available")
-        val keyedFix = fixesProvider()[source to catalogId]
-        // Master behavior for everything without a fix: return before touching
-        // path resolution. EA App titles (Steam only) are detected by their
-        // installer bundle and get the family fix without registration.
-        if (keyedFix == null && source != GameSource.STEAM) return
         val (installPath, installPathWindows) = resolvePaths(context, source, gameId) ?: return
-        val fix = keyedFix
-            ?: EaAppGameFix.takeIf { isEaAppGame(installPath) }
+        val fix = fixesProvider()[source to catalogId]
+            ?: EaAppGameFix.takeIf { source == GameSource.STEAM && isEaAppGame(installPath) }
             ?: return
         fix.apply(context, catalogId, installPath, installPathWindows, container)
     }

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

@@ -93,7 +93,6 @@ import app.gamenative.PrefManager
 import app.gamenative.SteamBootstrap
 import app.gamenative.data.GameSource
 import app.gamenative.gamefixes.GameFixesRegistry
-import app.gamenative.gamefixes.isEaAppGame
 import app.gamenative.gamefixes.GameInputCompatibility
 import app.gamenative.data.LaunchInfo
 import app.gamenative.data.LibraryItem
@@ -3783,20 +3782,11 @@ private fun setupXEnvironment(
 
     var preInstallCommands: List<PreInstallSteps.PreInstallCommand> = emptyList()
     var gameExecutable = ""
-
-    // EA App prefixes need the gamefix re-applied right before the game
-    // session: installer sessions overwrite its registry work on their
-    // wineserver flush, and on a cold install the EA binaries it targets only
-    // exist after the installer has run.
-    val reapplyEaGameFixes = {
-        val gameDir = ContainerUtils.extractGameIdFromContainerId(appId)
-            ?.let { SteamService.getAppDirPath(it) }.orEmpty()
-        if (gameDir.isNotEmpty() && isEaAppGame(gameDir)) {
-            try {
-                GameFixesRegistry.applyFor(context, appId, container)
-            } catch (e: Exception) {
-                Timber.tag("GameFixes").w(e, "EA gamefix reapply failed")
-            }
+    val applyGameFixesImmediatelyBeforeGuestLaunch = Runnable {
+        try {
+            GameFixesRegistry.applyFor(context, appId, container)
+        } catch (e: Exception) {
+            Timber.tag("GameFixes").w(e, "Game fixes failed immediately before guest launch")
         }
     }
 
@@ -3896,7 +3886,10 @@ private fun setupXEnvironment(
             if (preInstallCommands.isNotEmpty()) {
                 PluviaApp.events.emit(AndroidEvent.SetBootingSplashText("Installing prerequisites..."))
             } else {
-                reapplyEaGameFixes()
+                // start() has already performed its final wineserver shutdown
+                // before invoking this callback, so registry changes made here
+                // cannot be overwritten by the previous Wine session.
+                applyGameFixesImmediatelyBeforeGuestLaunch.run()
                 PluviaApp.events.emit(AndroidEvent.SetBootingSplashText("Launching game..."))
             }
         }
@@ -3978,6 +3971,13 @@ private fun setupXEnvironment(
 
     fun chainPreInstallSteps(remaining: List<PreInstallSteps.PreInstallCommand>) {
         if (remaining.isEmpty()) {
+            // Installers can create or replace the registry values and binaries
+            // that a gamefix targets. Apply the fix again after the final
+            // installer has fully exited. Defer the reapply to preUnpack: the
+            // component's start() performs one final wineserver shutdown before
+            // invoking it, then immediately starts the game. This prevents the
+            // old Wine registry server from overwriting the repaired protocol.
+            guestProgramLauncherComponent.setPreUnpack(applyGameFixesImmediatelyBeforeGuestLaunch)
             guestProgramLauncherComponent.setGuestExecutable(gameExecutable)
             guestProgramLauncherComponent.setTerminationCallback(gameTerminationCallback)
             return
@@ -3994,7 +3994,6 @@ private fun setupXEnvironment(
             }
             val nextRemaining = remaining.drop(1)
             if (nextRemaining.isEmpty()) {
-                reapplyEaGameFixes()
                 PluviaApp.events.emit(AndroidEvent.SetBootingSplashText("Launching game..."))
             } else {
                 PluviaApp.events.emit(AndroidEvent.SetBootingSplashText("Installing prerequisites..."))
@@ -4526,7 +4525,21 @@ private fun getWineStartCommand(
             guestProgramLauncherComponent.workingDir = File(executableDir)
             Timber.i("Bionic-Steam working directory is $executableDir")
             val gameFolderName = appDirPath.substringAfterLast('/').ifEmpty { gameId.toString() }
-            SteamUtils.buildBionicSteamLaunchCommand(gameFolderName, exePath, appLaunchInfo, gameId, appDirPath)
+            SteamUtils.buildBionicSteamLaunchCommand(
+                gameFolderName = gameFolderName,
+                executablePath = exePath,
+                appLaunchInfo = appLaunchInfo,
+                protocolTargetOverride = if (app.gamenative.gamefixes.isEaAppGame(appDirPath)) {
+                    "link2ea://launchgame/$gameId?platform=steam"
+                } else {
+                    null
+                },
+                protocolLaunchScriptWindowsPath = if (app.gamenative.gamefixes.isEaAppGame(appDirPath)) {
+                    app.gamenative.gamefixes.EA_LINK2EA_LAUNCH_SCRIPT_WINDOWS_PATH
+                } else {
+                    null
+                },
+            )
         } else if (container.isLaunchRealSteam) {
             // Launch Steam with the applaunch parameter to start the game
             "\"C:\\\\Program Files (x86)\\\\Steam\\\\steam.exe\" -silent -vgui -tcp " +

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

@@ -1,7 +1,5 @@
 package app.gamenative.utils
 
-import app.gamenative.gamefixes.EA_LINK2EA_LAUNCH_SCRIPT_WINDOWS_PATH
-import app.gamenative.gamefixes.isEaAppGame
 import android.annotation.SuppressLint
 import android.content.Context
 import android.provider.Settings
@@ -62,26 +60,14 @@ object SteamUtils {
         gameFolderName: String,
         executablePath: String,
         appLaunchInfo: LaunchInfo?,
-        gameId: Int,
-        appDirPath: String,
+        protocolTargetOverride: String? = null,
+        protocolLaunchScriptWindowsPath: String? = null,
     ): String {
-        // EA App titles must launch through EA: Steam hands the game to EA via
-        // its link2ea:// protocol, and EA authenticates the session with an
-        // exchange token minted from the Steam login.
-        // Only EA App titles take the protocol path; every other game launches
-        // exactly as before. Steam's launch config carries link2ea:// for most
-        // EA titles; fall back to building the URL from the appid.
-        val isEaApp = isEaAppGame(appDirPath)
-        val protocolTarget = if (!isEaApp) {
-            null
-        } else {
-            (appLaunchInfo?.executable ?: "link2ea://launchgame/$gameId?platform=steam")
-                .trim()
-                .takeIf { target ->
-                    target.matches(Regex("^[A-Za-z][A-Za-z0-9+.-]*://[^\\s\\\"]+$"))
-                }
-                ?: "link2ea://launchgame/$gameId?platform=steam"
-        }
+        val protocolTarget = (appLaunchInfo?.executable ?: protocolTargetOverride)
+            ?.trim()
+            ?.takeIf { target ->
+                target.matches(Regex("^[A-Za-z][A-Za-z0-9+.-]*://[^\\s\\\"]+$"))
+            }
         if (protocolTarget != null) {
             // A gamefix-owned launch script can gate the protocol handoff (for
             // example waiting for EABackgroundService before Link2EA fires).
@@ -90,9 +76,9 @@ object SteamUtils {
             // The script path must not contain spaces: the command goes through
             // winhandler's argument parsing, which breaks on cmd's nested-quote
             // form, so the script is passed as a bare token.
-            if (isEaApp) {
+            if (protocolLaunchScriptWindowsPath != null) {
                 return "\"C:\\\\windows\\\\system32\\\\cmd.exe\" /d /c " +
-                    "$EA_LINK2EA_LAUNCH_SCRIPT_WINDOWS_PATH \"$protocolTarget\""
+                    "$protocolLaunchScriptWindowsPath \"$protocolTarget\""
             }
             return "\"C:\\\\windows\\\\system32\\\\start.exe\" \"$protocolTarget\""
         }