Refactor Linux outside-click watcher: replace JNA with JNI, add dynamic X11 support, and update reachability metadata.

Author: kdroidFilter

demo/build.gradle.kts

@@ -29,7 +29,7 @@ kotlin {
 }
 
 nucleus.application {
-    mainClass = "com.kdroid.composetray.demo.DynamicTrayMenuKt"
+    mainClass = "com.kdroid.composetray.demo.TrayAppDemoKt"
 
     buildTypes {
         release {

demo/src/jvmMain/kotlin/com/kdroid/composetray/demo/TrayAppDemo.kt

@@ -26,11 +26,20 @@ import com.kdroid.composetray.utils.allowComposeNativeTrayLogging
 import composenativetray.demo.generated.resources.Res
 import composenativetray.demo.generated.resources.icon
 import io.github.kdroidfilter.nucleus.darkmodedetector.isSystemInDarkMode
+import io.github.kdroidfilter.nucleus.graalvm.GraalVmInitializer
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
+import java.io.File
 
 @OptIn(ExperimentalTrayAppApi::class)
 fun main() {
+    GraalVmInitializer.initialize()
+    if (System.getProperty("skiko.renderApi") == null) {
+        val os = System.getProperty("os.name")?.lowercase() ?: ""
+        if (os.contains("linux") && isNvidiaGpuPresent()) {
+            System.setProperty("skiko.renderApi", "SOFTWARE")
+        }
+    }
     allowComposeNativeTrayLogging = true
     application {
         var isWindowVisible by remember { mutableStateOf(true) }
@@ -265,4 +274,21 @@ fun main() {
             }
         }
     }
-}
+}
+
+private fun isNvidiaGpuPresent(): Boolean {
+    // Check if NVIDIA driver is loaded by looking for the driver version file
+    val nvidiaDriverFile = File("/proc/driver/nvidia/version")
+    if (nvidiaDriverFile.exists()) return true
+
+    // Fallback: try running nvidia-smi
+    return try {
+        val process = ProcessBuilder("nvidia-smi", "-L")
+            .redirectErrorStream(true)
+            .start()
+        val exitCode = process.waitFor()
+        exitCode == 0
+    } catch (_: Exception) {
+        false
+    }
+}

src/jvmMain/kotlin/com/kdroid/composetray/lib/linux/LinuxNativeBridge.kt

@@ -66,4 +66,18 @@ internal object LinuxNativeBridge {
     @JvmStatic external fun nativeItemCheck(handle: Long, id: Int)
     @JvmStatic external fun nativeItemUncheck(handle: Long, id: Int)
     @JvmStatic external fun nativeItemSetIcon(handle: Long, id: Int, iconBytes: ByteArray)
+
+    // -- X11 outside-click watcher -----------------------------------------------
+
+    /** Open X11 display. Returns handle, or 0 if X11 is unavailable. */
+    @JvmStatic external fun nativeX11OpenDisplay(): Long
+
+    /** Get default root window for the display. */
+    @JvmStatic external fun nativeX11DefaultRootWindow(displayHandle: Long): Long
+
+    /** Query pointer. Writes [rootX, rootY, mask] into outData. Returns 1 on success. */
+    @JvmStatic external fun nativeX11QueryPointer(displayHandle: Long, rootWindow: Long, outData: IntArray): Int
+
+    /** Close X11 display. */
+    @JvmStatic external fun nativeX11CloseDisplay(displayHandle: Long)
 }

src/jvmMain/kotlin/com/kdroid/composetray/lib/linux/LinuxOutsideClickWatcher.kt

@@ -1,48 +1,19 @@
 package com.kdroid.composetray.lib.linux
 
 import com.kdroid.composetray.utils.isPointWithinLinuxStatusItem
-import com.sun.jna.Library
-import com.sun.jna.Native
-import com.sun.jna.NativeLong
-import com.sun.jna.Pointer
-import com.sun.jna.ptr.IntByReference
-import com.sun.jna.ptr.NativeLongByReference
 import io.github.kdroidfilter.platformtools.OperatingSystem
 import io.github.kdroidfilter.platformtools.getOperatingSystem
 import java.awt.Window
 import java.util.concurrent.Executors
 import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.TimeUnit
 
-/**
- * Minimal X11 binding for what we need.
- */
-internal interface X11 : Library {
-    companion object {
-        val INSTANCE: X11 = Native.load("X11", X11::class.java)
-    }
-
-    fun XOpenDisplay(displayName: String?): Pointer?
-    fun XDefaultRootWindow(display: Pointer?): NativeLong
-    fun XQueryPointer(
-        display: Pointer?,
-        w: NativeLong,
-        root_return: NativeLongByReference,
-        child_return: NativeLongByReference,
-        root_x_return: IntByReference,
-        root_y_return: IntByReference,
-        win_x_return: IntByReference,
-        win_y_return: IntByReference,
-        mask_return: IntByReference
-    ): Int
-
-    fun XCloseDisplay(display: Pointer?): Int
-}
-
 /**
  * LinuxOutsideClickWatcher: X11/XWayland implementation that detects a left-click anywhere,
  * and if it is outside the supplied window (and not on the tray icon area), invokes a callback.
  *
+ * Uses JNI via LinuxNativeBridge for X11 calls (no JNA dependency).
+ *
  * Notes:
  * - Requires X11/XWayland (DISPLAY must be set). Will no-op on Wayland-only sessions without XWayland.
  * - Polls with XQueryPointer at ~60 Hz, reading Button1Mask for "left pressed".
@@ -55,25 +26,20 @@ class LinuxOutsideClickWatcher(
     private var scheduler: ScheduledExecutorService? = null
     private var prevLeft = false
 
-    // X11 state
-    private var display: Pointer? = null
-    private var rootWindow: NativeLong = NativeLong(0)
+    // X11 state (native handles)
+    private var displayHandle: Long = 0L
+    private var rootWindow: Long = 0L
 
     fun start() {
         if (getOperatingSystem() != OperatingSystem.LINUX) return
         if (scheduler != null) return
 
         try {
-            val x11 = X11.INSTANCE
-            display = x11.XOpenDisplay(null)
-            if (display == null) {
-                // No X11 available (e.g., Wayland-only session) -> do nothing.
-                return
-            }
-            rootWindow = x11.XDefaultRootWindow(display)
+            displayHandle = LinuxNativeBridge.nativeX11OpenDisplay()
+            if (displayHandle == 0L) return
+            rootWindow = LinuxNativeBridge.nativeX11DefaultRootWindow(displayHandle)
         } catch (_: Throwable) {
-            // Failed to connect to X11 -> do nothing.
-            display = null
+            displayHandle = 0L
             return
         }
 
@@ -85,42 +51,21 @@ class LinuxOutsideClickWatcher(
     }
 
     private fun pollOnce() {
-        val dpy = display ?: return
+        if (displayHandle == 0L) return
         try {
-            val x11 = X11.INSTANCE
-
-            val rootRet = NativeLongByReference()
-            val childRet = NativeLongByReference()
-            val rootX = IntByReference()
-            val rootY = IntByReference()
-            val winX = IntByReference()
-            val winY = IntByReference()
-            val mask = IntByReference()
-
-            // Bool return (0 = False, non-zero = True)
-            val ok = x11.XQueryPointer(
-                dpy,
-                rootWindow,
-                rootRet,
-                childRet,
-                rootX,
-                rootY,
-                winX,
-                winY,
-                mask
-            ) != 0
-
+            val outData = IntArray(3) // [rootX, rootY, mask]
+            val ok = LinuxNativeBridge.nativeX11QueryPointer(displayHandle, rootWindow, outData) != 0
             if (!ok) return
 
-            val left = (mask.value and BUTTON1_MASK) != 0
+            val px = outData[0]
+            val py = outData[1]
+            val mask = outData[2]
+            val left = (mask and BUTTON1_MASK) != 0
 
             // Rising edge: only act once when the button goes down
             if (left && left != prevLeft) {
                 val win = windowSupplier.invoke()
                 if (win != null && win.isShowing) {
-                    val px = rootX.value
-                    val py = rootY.value
-
                     val winLoc = try { win.locationOnScreen } catch (_: Throwable) { null }
                     if (winLoc != null) {
                         val wx = winLoc.x
@@ -150,14 +95,12 @@ class LinuxOutsideClickWatcher(
         try { scheduler?.shutdownNow() } catch (_: Throwable) {}
         scheduler = null
 
-        // Close X11 display after stopping the poller
         try {
-            display?.let { X11.INSTANCE.XCloseDisplay(it) }
+            if (displayHandle != 0L) LinuxNativeBridge.nativeX11CloseDisplay(displayHandle)
         } catch (_: Throwable) {
-            // ignore
         } finally {
-            display = null
-            rootWindow = NativeLong(0)
+            displayHandle = 0L
+            rootWindow = 0L
         }
     }
 

src/jvmMain/resources/META-INF/native-image/io.github.kdroidfilter/composenativetray/reachability-metadata.json

@@ -28,6 +28,16 @@
                 }
             ]
         },
+        {
+            "type": "sun.awt.X11GraphicsConfig",
+            "jniAccessible": true,
+            "methods": [
+                {
+                    "name": "createDCM32",
+                    "parameterTypes": ["int", "int", "int", "int", "boolean"]
+                }
+            ]
+        },
         {
             "type": "java.lang.Runnable",
             "jniAccessible": true,

src/native/linux/build.sh

@@ -64,7 +64,7 @@ gcc -shared -o "$OUTPUT_DIR/linux-x86-64/libLinuxTray.so" \
     "$SCRIPT_DIR/sni.o" \
     "$SCRIPT_DIR/jni_bridge.o" \
     $SDBUS_LIBS \
-    -lpthread -lm
+    -lpthread -lm -ldl
 
 # Strip debug symbols for smaller binary
 strip --strip-unneeded "$OUTPUT_DIR/linux-x86-64/libLinuxTray.so"

src/native/linux/jni_bridge.c

@@ -15,6 +15,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
+#include <dlfcn.h>
 
 #include "sni.h"
 
@@ -489,3 +490,99 @@ Java_com_kdroid_composetray_lib_linux_LinuxNativeBridge_nativeItemSetIcon(
     sni_tray_item_set_icon(tray, (uint32_t)id, (const uint8_t *)buf, (size_t)len);
     (*env)->ReleaseByteArrayElements(env, iconBytes, buf, JNI_ABORT);
 }
+
+/* ========================================================================== */
+/*  X11 outside-click watcher (dynamically loaded to avoid hard dependency)   */
+/* ========================================================================== */
+
+/* X11 types */
+typedef void *X11Display;
+typedef unsigned long X11Window;
+typedef int X11Bool;
+
+/* X11 function pointers (loaded via dlopen/dlsym) */
+typedef X11Display (*fn_XOpenDisplay)(const char *);
+typedef X11Window  (*fn_XDefaultRootWindow)(X11Display);
+typedef X11Bool    (*fn_XQueryPointer)(X11Display, X11Window,
+                                      X11Window *, X11Window *,
+                                      int *, int *, int *, int *,
+                                      unsigned int *);
+typedef int        (*fn_XCloseDisplay)(X11Display);
+
+static void        *g_x11_lib = NULL;
+static fn_XOpenDisplay       g_XOpenDisplay = NULL;
+static fn_XDefaultRootWindow g_XDefaultRootWindow = NULL;
+static fn_XQueryPointer      g_XQueryPointer = NULL;
+static fn_XCloseDisplay      g_XCloseDisplay = NULL;
+
+static int ensure_x11(void) {
+    if (g_x11_lib) return 1;
+    g_x11_lib = dlopen("libX11.so.6", RTLD_LAZY);
+    if (!g_x11_lib) g_x11_lib = dlopen("libX11.so", RTLD_LAZY);
+    if (!g_x11_lib) return 0;
+    g_XOpenDisplay       = (fn_XOpenDisplay)dlsym(g_x11_lib, "XOpenDisplay");
+    g_XDefaultRootWindow = (fn_XDefaultRootWindow)dlsym(g_x11_lib, "XDefaultRootWindow");
+    g_XQueryPointer      = (fn_XQueryPointer)dlsym(g_x11_lib, "XQueryPointer");
+    g_XCloseDisplay      = (fn_XCloseDisplay)dlsym(g_x11_lib, "XCloseDisplay");
+    if (!g_XOpenDisplay || !g_XDefaultRootWindow || !g_XQueryPointer || !g_XCloseDisplay) {
+        dlclose(g_x11_lib);
+        g_x11_lib = NULL;
+        return 0;
+    }
+    return 1;
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_kdroid_composetray_lib_linux_LinuxNativeBridge_nativeX11OpenDisplay(
+    JNIEnv *env, jclass clazz)
+{
+    (void)env; (void)clazz;
+    if (!ensure_x11()) return 0;
+    X11Display dpy = g_XOpenDisplay(NULL);
+    return (jlong)(uintptr_t)dpy;
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_kdroid_composetray_lib_linux_LinuxNativeBridge_nativeX11DefaultRootWindow(
+    JNIEnv *env, jclass clazz, jlong displayHandle)
+{
+    (void)env; (void)clazz;
+    if (!g_XDefaultRootWindow) return 0;
+    X11Display dpy = (X11Display)(uintptr_t)displayHandle;
+    if (!dpy) return 0;
+    return (jlong)g_XDefaultRootWindow(dpy);
+}
+
+JNIEXPORT jint JNICALL
+Java_com_kdroid_composetray_lib_linux_LinuxNativeBridge_nativeX11QueryPointer(
+    JNIEnv *env, jclass clazz, jlong displayHandle, jlong rootWindow, jintArray outData)
+{
+    (void)clazz;
+    if (!g_XQueryPointer) return 0;
+    X11Display dpy = (X11Display)(uintptr_t)displayHandle;
+    if (!dpy || !outData) return 0;
+
+    X11Window root_ret, child_ret;
+    int root_x, root_y, win_x, win_y;
+    unsigned int mask;
+
+    X11Bool ok = g_XQueryPointer(dpy, (X11Window)(unsigned long)rootWindow,
+                                 &root_ret, &child_ret,
+                                 &root_x, &root_y, &win_x, &win_y, &mask);
+
+    /* outData: [rootX, rootY, mask] */
+    jint buf[3] = {(jint)root_x, (jint)root_y, (jint)mask};
+    (*env)->SetIntArrayRegion(env, outData, 0, 3, buf);
+
+    return (jint)(ok != 0 ? 1 : 0);
+}
+
+JNIEXPORT void JNICALL
+Java_com_kdroid_composetray_lib_linux_LinuxNativeBridge_nativeX11CloseDisplay(
+    JNIEnv *env, jclass clazz, jlong displayHandle)
+{
+    (void)env; (void)clazz;
+    if (!g_XCloseDisplay) return;
+    X11Display dpy = (X11Display)(uintptr_t)displayHandle;
+    if (dpy) g_XCloseDisplay(dpy);
+}