IJPL-54591 Implement IDE theme sync with OS on Linux

- Fixed comments from CR


(cherry picked from commit 115bea227f7bedd58fe401d8376b3ee7b05862c3)

IJ-CR-192442

GitOrigin-RevId: 5ef849ccb84e2fa7056d36d138ebeeadc5115746

Author: pporvatov

platform/platform-impl/src/com/intellij/ide/ui/laf/DBusSettingsMonitorService.kt

@@ -1,20 +1,27 @@
 // Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.ide.ui.laf
 
+import com.intellij.openapi.application.EDT
+import com.intellij.openapi.application.ModalityState
+import com.intellij.openapi.application.asContextElement
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.thisLogger
 import com.intellij.openapi.util.SystemInfoRt
 import com.intellij.openapi.wm.impl.ExecResult
-import com.intellij.openapi.wm.impl.X11UiUtilKt
+import com.intellij.openapi.wm.impl.LinuxUiUtil
 import com.intellij.openapi.wm.impl.output
 import com.intellij.util.concurrency.ThreadingAssertions
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.FlowPreview
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import java.util.concurrent.atomic.AtomicReference
 import kotlin.time.Duration.Companion.seconds
 
@@ -41,14 +48,13 @@ private val QUERY_COLOR_SCHEME = arrayOf(
   "string:org.freedesktop.appearance",
   "string:color-scheme")
 
-@Suppress("OPT_IN_USAGE")
 @Service
 internal class DBusSettingsMonitorService(private val scope: CoroutineScope) {
 
   private var LOG = thisLogger()
 
   private val darkSchemeFlow = MutableStateFlow<Boolean?>(null)
-  private val darkSchemeDebounceFlow = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
+  private val darkSchemeDebounceFlow = MutableSharedFlow<Unit>(extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_LATEST)
   private var dbusMonitorProcess = AtomicReference<Process?>(null)
 
   val isServiceAllowed: Boolean
@@ -62,6 +68,7 @@ internal class DBusSettingsMonitorService(private val scope: CoroutineScope) {
         darkSchemeFlow.value = calcDarkScheme()
 
         try {
+          @OptIn(FlowPreview::class)
           darkSchemeDebounceFlow.debounce(DEBOUNCE_DURATION).collect {
             darkSchemeFlow.value = calcDarkScheme()
           }
@@ -87,7 +94,7 @@ internal class DBusSettingsMonitorService(private val scope: CoroutineScope) {
       return
     }
 
-    scope.launch {
+    scope.launch(Dispatchers.EDT + ModalityState.any().asContextElement()) {
       darkScheme.collect {
         listener(it ?: false)
       }
@@ -97,7 +104,7 @@ internal class DBusSettingsMonitorService(private val scope: CoroutineScope) {
   private fun calcDarkScheme(): Boolean? {
     ThreadingAssertions.assertBackgroundThread()
 
-    val output = X11UiUtilKt.exec("DBusSettingsMonitorService gets color scheme", *QUERY_COLOR_SCHEME).output() ?: return null
+    val output = LinuxUiUtil.exec("DBusSettingsMonitorService gets color scheme", *QUERY_COLOR_SCHEME).output() ?: return null
 
     val split = output.splitOutput()
     val value = split.lastOrNull()?.toIntOrNull()
@@ -124,36 +131,40 @@ internal class DBusSettingsMonitorService(private val scope: CoroutineScope) {
     return result
   }
 
-  private fun startDbusMonitorListener() {
-    ThreadingAssertions.assertBackgroundThread()
-
-    if (X11UiUtilKt.exec("DBusSettingsMonitorService checks dbus-monitor", *CHECK_MONITOR_CMD) !is ExecResult.Success) {
-      return
-    }
+  /**
+   * The method starts a process and reads its output for the entire lifetime of the IDE.
+   * It uses I/O operations and doesn't obey coroutine cancellation
+   */
+  private suspend fun startDbusMonitorListener() {
+    withContext(Dispatchers.IO) {
+      if (LinuxUiUtil.exec("DBusSettingsMonitorService checks dbus-monitor", *CHECK_MONITOR_CMD) !is ExecResult.Success) {
+        return@withContext
+      }
 
-    try {
-      dbusMonitorProcess.set(ProcessBuilder(*MONITOR_CMD).start())
-      LOG.info("DBus listener started")
-    }
-    catch (e: Throwable) {
-      LOG.info("DBus listener cannot start", e)
-    }
+      try {
+        dbusMonitorProcess.set(ProcessBuilder(*MONITOR_CMD).start())
+        LOG.info("DBus listener started")
+      }
+      catch (e: Throwable) {
+        LOG.info("DBus listener cannot start", e)
+      }
 
-    val process = dbusMonitorProcess.get() ?: return
+      val process = dbusMonitorProcess.get() ?: return@withContext
 
-    try {
-      process.inputStream.bufferedReader().forEachLine { line ->
-        val split = line.splitOutput()
-        if (split.size > 2 && split[split.size - 2] == SETTINGS_INTERFACE && split[split.size - 1] == SETTINGS_MEMBER) {
-          LOG.info("SettingChanged received: $line")
-          darkSchemeDebounceFlow.tryEmit(Unit)
+      try {
+        process.inputStream.bufferedReader().forEachLine { line ->
+          val split = line.splitOutput()
+          if (split.size > 2 && split[split.size - 2] == SETTINGS_INTERFACE && split[split.size - 1] == SETTINGS_MEMBER) {
+            LOG.info("SettingChanged received: $line")
+            check(darkSchemeDebounceFlow.tryEmit(Unit))
+          }
         }
-      }
 
-      LOG.info("DBus listener stopped: output ended unexpectedly (no errors)")
-    }
-    catch (e: Throwable) {
-      LOG.info("DBus listener stopped", e)
+        LOG.info("DBus listener stopped: output ended unexpectedly (no errors)")
+      }
+      catch (e: Throwable) {
+        LOG.info("DBus listener stopped", e)
+      }
     }
   }
 

…/intellij/openapi/wm/impl/X11UiUtilKt.kt …/intellij/openapi/wm/impl/LinuxUiUtil.ktplatform/platform-impl/src/com/intellij/openapi/wm/impl/X11UiUtilKt.kt renamed to platform/platform-impl/src/com/intellij/openapi/wm/impl/LinuxUiUtil.kt platform/platform-impl/src/com/intellij/openapi/wm/impl/X11UiUtilKt.kt renamed to platform/platform-impl/src/com/intellij/openapi/wm/impl/LinuxUiUtil.kt

@@ -1,12 +1,14 @@
 // Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.openapi.wm.impl
 
+import com.intellij.execution.ExecutionException
+import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.execution.process.ProcessNotCreatedException
+import com.intellij.execution.util.ExecUtil
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.util.concurrency.ThreadingAssertions
 import org.jetbrains.annotations.ApiStatus
-import java.nio.charset.StandardCharsets
 import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.TimeUnit
 
 @ApiStatus.Internal
 sealed interface ExecResult {
@@ -20,12 +22,16 @@ sealed interface ExecResult {
 }
 
 @ApiStatus.Internal
-internal object X11UiUtilKt {
+object LinuxUiUtil {
 
-  private val LOG = logger<X11UiUtilKt>()
+  private val LOG = logger<LinuxUiUtil>()
 
   private val unsupportedCommands = ConcurrentHashMap<String, Boolean>()
 
+  /**
+   * Executes the command and returns its output. If the command is unsupported by OS, returns [ExecResult.Failure] and doesn't
+   * try to execute/log the problem anymore
+   */
   @JvmStatic
   fun exec(errorMessage: String, vararg command: String): ExecResult {
     ThreadingAssertions.assertBackgroundThread()
@@ -41,36 +47,38 @@ internal object X11UiUtilKt {
     }
 
     try {
-      val process = ProcessBuilder(*command).start()
-      if (!process.waitFor(5, TimeUnit.SECONDS)) {
-        LOG.info("$errorMessage: timeout")
-        process.destroyForcibly()
-        return ExecResult.Failure()
+      val processOutput = ExecUtil.execAndGetOutput(GeneralCommandLine(*command), 5000)
+      val exitCode = processOutput.exitCode
+      if (exitCode != 0) {
+        LOG.debug("$errorMessage: exit code $exitCode")
+        return ExecResult.ExitValue(exitCode)
       }
 
-      if (process.exitValue() != 0) {
-        LOG.info(errorMessage + ": exit code " + process.exitValue())
-        return ExecResult.ExitValue(process.exitValue())
-      }
-      val output = process.inputReader(StandardCharsets.UTF_8).readText().trim { it <= ' ' }
+      val output = processOutput.stdout.trim { it <= ' ' }
       return ExecResult.Success(output)
     }
-    catch (e: Exception) {
-      val exceptionMessage = e.message
-      if (exceptionMessage?.contains("No such file or directory") == true) {
+    catch (e: ExecutionException) {
+      if (e is ProcessNotCreatedException && isNoFileOrDirectory(e.cause)) {
         unsupportedCommands[command[0]] = true
-        LOG.info("$errorMessage: $exceptionMessage")
+        LOG.info("$errorMessage: ${e.message}")
         LOG.trace(e)
       }
       else {
         LOG.info(errorMessage, e)
       }
-
       return ExecResult.Failure()
     }
   }
 }
 
+/**
+ * There is no good API in jdk for such a check. The string comes from the JDK and is not localizable
+ * (see os.cpp: `X(ENOENT, "No such file or directory")`), therefore, this solution should work on different OS-s and locales.
+ */
+private fun isNoFileOrDirectory(e: Throwable?): Boolean {
+  return e?.message?.contains("No such file or directory") == true
+}
+
 @ApiStatus.Internal
 fun ExecResult.output(): String? {
   return (this as? ExecResult.Success)?.output

platform/platform-impl/src/com/intellij/openapi/wm/impl/X11UiUtil.java

@@ -520,8 +520,8 @@ private static Field field(Class<?> aClass, String name) throws Exception {
   }
 
   private static @Nullable String exec(String errorMessage, String... command) {
-    var execResult = X11UiUtilKt.exec(errorMessage, command);
-    return X11UiUtilKtKt.output(execResult);
+    var execResult = LinuxUiUtil.exec(errorMessage, command);
+    return LinuxUiUtilKt.output(execResult);
   }
 
   private static List<String> grepFile(@SuppressWarnings("SameParameterValue") String errorMessage, Path file, Pattern pattern) {