Global (Android): enable X11 related stuff

src/detection/displayserver/displayserver.h

@@ -44,6 +44,7 @@
 #define FF_WM_PROTOCOL_TTY "TTY"
 #define FF_WM_PROTOCOL_X11 "X11"
 #define FF_WM_PROTOCOL_WAYLAND "Wayland"
+#define FF_WM_PROTOCOL_SURFACEFLINGER "SurfaceFlinger"
 
 typedef enum __attribute__((__packed__)) FFDisplayType {
     FF_DISPLAY_TYPE_UNKNOWN,

src/detection/displayserver/displayserver_android.c

@@ -1,6 +1,7 @@
 #include "displayserver.h"
 #include "common/settings.h"
 #include "common/processing.h"
+#include "linux/displayserver_linux.h"
 
 #include <math.h>
 
@@ -147,10 +148,19 @@ static bool detectWithGetprop(FFDisplayServerResult* ds)
 
 void ffConnectDisplayServerImpl(FFDisplayServerResult* ds)
 {
+    const char* error = ffdsConnectXcbRandr(ds);
+    if (error)
+        error = ffdsConnectXrandr(ds);
+    if (!error)
+    {
+        ffdsDetectWMDE(ds);
+        return;
+    }
+
     // https://source.android.com/docs/core/graphics/surfaceflinger-windowmanager
     ffStrbufSetStatic(&ds->wmProcessName, "system_server");
     ffStrbufSetStatic(&ds->wmPrettyName, "WindowManager"); // A system service managed by system_server
-    ffStrbufSetStatic(&ds->wmProtocolName, "SurfaceFlinger");
+    ffStrbufSetStatic(&ds->wmProtocolName, FF_WM_PROTOCOL_SURFACEFLINGER);
 
     if (!detectWithGetprop(ds))
         detectWithDumpsys(ds);

src/detection/displayserver/linux/common.c

@@ -0,0 +1,16 @@
+#include "displayserver_linux.h"
+#include "util/stringUtils.h"
+
+FFDisplayType ffdsGetDisplayType(const char* name)
+{
+    if(ffStrStartsWith(name, "eDP-") || ffStrStartsWith(name, "LVDS-"))
+        return FF_DISPLAY_TYPE_BUILTIN;
+    else if(ffStrStartsWith(name, "HDMI-") ||
+            ffStrStartsWith(name, "DP-") ||
+            ffStrStartsWith(name, "DisplayPort-") ||
+            ffStrStartsWith(name, "DVI-") ||
+            ffStrStartsWith(name, "VGA-"))
+        return FF_DISPLAY_TYPE_EXTERNAL;
+
+    return FF_DISPLAY_TYPE_UNKNOWN;
+}

src/detection/displayserver/linux/displayserver_linux.c

@@ -95,17 +95,3 @@ void ffConnectDisplayServerImpl(FFDisplayServerResult* ds)
         ffdsDetectWMDE(ds);
     }
 }
-
-FFDisplayType ffdsGetDisplayType(const char* name)
-{
-    if(ffStrStartsWith(name, "eDP-") || ffStrStartsWith(name, "LVDS-"))
-        return FF_DISPLAY_TYPE_BUILTIN;
-    else if(ffStrStartsWith(name, "HDMI-") ||
-            ffStrStartsWith(name, "DP-") ||
-            ffStrStartsWith(name, "DisplayPort-") ||
-            ffStrStartsWith(name, "DVI-") ||
-            ffStrStartsWith(name, "VGA-"))
-        return FF_DISPLAY_TYPE_EXTERNAL;
-
-    return FF_DISPLAY_TYPE_UNKNOWN;
-}

src/detection/displayserver/linux/wmde.c

@@ -65,7 +65,7 @@ static const char* parseEnv(void)
     if(getenv("SWAYSOCK") != NULL)
         return "Sway";
 
-    #ifdef __linux__
+    #if __linux__ && !__ANDROID__
     if(
         getenv("WAYLAND_DISPLAY") != NULL &&
         ffPathExists("/mnt/wslg/", FF_PATHTYPE_DIRECTORY)
@@ -433,6 +433,11 @@ static const char* getFromProcesses(FFDisplayServerResult* result)
 
 void ffdsDetectWMDE(FFDisplayServerResult* result)
 {
+    #if __ANDROID__
+    if(ffStrbufIgnCaseEqualS(&result->wmProtocolName, FF_WM_PROTOCOL_SURFACEFLINGER))
+        return; // Only supported when connected to X11
+    #endif
+
     const char* env = parseEnv();
 
     if(result->wmProcessName.length > 0)

src/detection/font/font_linux.c

@@ -28,7 +28,7 @@ const char* ffDetectFontImpl(FFFontResult* result)
 {
     const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
-    if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY) == 0)
+    if(ffStrbufIgnCaseEqualS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY))
         return "Font isn't supported in TTY";
 
     FFfont qt;

src/detection/icons/icons_linux.c

@@ -7,7 +7,7 @@ const char* ffDetectIcons(FFIconsResult* result)
 {
     const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
-    if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY) == 0)
+    if(ffStrbufIgnCaseEqualS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY))
         return "Icons aren't supported in TTY";
 
     const FFstrbuf* plasma = &ffDetectQt()->icons;

src/detection/terminalfont/terminalfont.c

@@ -266,7 +266,7 @@ static bool detectRio(FFTerminalFontResult* terminalFont)
     return true;
 }
 
-void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont);
+bool ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont);
 
 static bool detectTerminalFontCommon(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
 {

src/detection/terminalfont/terminalfont_android.c

@@ -13,6 +13,12 @@
 
 const char* detectTermux(FFTerminalFontResult* terminalFont)
 {
+    if(!ffPathExists(FF_TERMUX_FONT_PATH, FF_PATHTYPE_FILE))
+    {
+        ffFontInitCopy(&terminalFont->font, "monospace");
+        return NULL;
+    }
+
     #ifdef FF_HAVE_FREETYPE
 
     FF_LIBRARY_LOAD(freetype, "dlopen libfreetype"FF_LIBRARY_EXTENSION " failed", "libfreetype"FF_LIBRARY_EXTENSION, 2)
@@ -53,19 +59,15 @@ exit:
     #endif
 }
 
-void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
+bool ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
 {
-    if(ffStrbufCompS(&terminal->processName, "com.termux") != 0)
+    if(ffStrbufEqualS(&terminal->processName, "com.termux"))
+        ffStrbufSetS(&terminalFont->error, detectTermux(terminalFont));
+    else
     {
-        ffStrbufSetS(&terminalFont->error, "Unsupported terminal");
-        return;
+        bool ffDetectTerminalFontPlatformLinux(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont);
+        return ffDetectTerminalFontPlatformLinux(terminal, terminalFont);
     }
 
-    if(!ffPathExists(FF_TERMUX_FONT_PATH, FF_PATHTYPE_FILE))
-    {
-        ffFontInitCopy(&terminalFont->font, "monospace");
-        return;
-    }
-
-    ffStrbufSetS(&terminalFont->error, detectTermux(terminalFont));
+    return true;
 }

src/detection/terminalfont/terminalfont_apple.m

@@ -91,7 +91,7 @@ static void detectWarpTerminal(FFTerminalFontResult* terminalFont)
     ffFontInitValues(&terminalFont->font, fontName.UTF8String, fontSize.UTF8String);
 }
 
-void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
+bool ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
 {
     if(ffStrbufIgnCaseEqualS(&terminal->processName, "iterm.app") ||
         ffStrbufStartsWithIgnCaseS(&terminal->processName, "iTermServer-"))
@@ -100,4 +100,7 @@ void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFo
         detectAppleTerminal(terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminal->processName, "WarpTerminal"))
         detectWarpTerminal(terminalFont);
+    else
+        return false;
+    return true;
 }

src/detection/terminalfont/terminalfont_linux.c

@@ -167,7 +167,7 @@ static void detectXFCETerminal(FFTerminalFontResult* terminalFont)
         });
     }
 
-    if(configFound && (useSysFont.length == 0 || ffStrbufIgnCaseCompS(&useSysFont, "false") == 0))
+    if(configFound && (useSysFont.length == 0 || ffStrbufIgnCaseEqualS(&useSysFont, "false")))
     {
         if(fontName.length == 0)
             ffStrbufAppendF(&terminalFont->error, "Couldn't find FontName in %s", path);
@@ -433,7 +433,13 @@ static void detectHaikuTerminal(FFTerminalFontResult* terminalFont)
 }
 #endif
 
-void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
+bool
+#ifdef __ANDROID__
+ffDetectTerminalFontPlatformLinux
+#else
+ffDetectTerminalFontPlatform
+#endif
+(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
 {
     if(ffStrbufIgnCaseEqualS(&terminal->processName, "konsole"))
         detectKonsole(terminalFont, "konsolerc");
@@ -477,4 +483,7 @@ void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFo
     #endif
     else if(ffStrbufStartsWithIgnCaseS(&terminal->processName, "termite"))
         detectFromConfigFile("termite/config", "font =", terminalFont);
+    else
+        return false;
+    return true;
 }

src/detection/terminalfont/terminalfont_windows.c

@@ -274,7 +274,7 @@ static void detectWarp(FFTerminalFontResult* terminalFont)
     ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
 }
 
-void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
+bool ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
 {
     if(ffStrbufIgnCaseEqualS(&terminal->processName, "Windows Terminal") ||
         ffStrbufIgnCaseEqualS(&terminal->processName, "WindowsTerminal.exe"))
@@ -287,4 +287,7 @@ void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFo
         detectConEmu(terminalFont);
     else if(ffStrbufStartsWithIgnCaseS(&terminal->processName, "warp"))
         detectWarp(terminalFont);
+    else
+        return false;
+    return true;
 }

src/detection/theme/theme_linux.c

@@ -7,7 +7,7 @@ const char* ffDetectTheme(FFThemeResult* result)
 {
     const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
-    if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY) == 0)
+    if(ffStrbufIgnCaseEqualS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY))
         return "Theme isn't supported in TTY";
 
     const FFQtResult* plasma = ffDetectQt();

src/detection/wm/wm_linux.c

@@ -13,6 +13,17 @@ const char* ffDetectWMPlugin(FF_MAYBE_UNUSED FFstrbuf* pluginName)
     return "Not supported on this platform";
 }
 
+static bool extractCommonWmVersion(const char* line, FF_MAYBE_UNUSED uint32_t len, void *userdata)
+{
+    int count = 0;
+    sscanf(line, "%*d.%*d.%*d%n", &count);
+    if (count == 0) return true;
+
+    ffStrbufSetNS((FFstrbuf*) userdata, len, line);
+    return false;
+}
+
+#if !__ANDROID__
 static bool extractHyprlandVersion(const char* line, uint32_t len, void *userdata)
 {
     if (line[0] != 'v') return true;
@@ -128,6 +139,48 @@ static const char* getSway(FFstrbuf* result)
     return "Failed to run command `sway --version`";
 }
 
+static const char* getLabwc(FFstrbuf* result)
+{
+    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
+    const char* error = ffFindExecutableInPath("labwc", &path);
+    if (error) return "Failed to find labwc executable path";
+
+    ffBinaryExtractStrings(path.chars, extractCommonWmVersion, result, (uint32_t) strlen("0.0.0"));
+    if (result->length > 0) return NULL;
+
+    if (ffProcessAppendStdOut(result, (char* const[]){
+        path.chars,
+        "--version",
+        NULL
+    }) == NULL)
+    { // labwc 0.9.0 (+xwayland +nls +rsvg +libsfdo)
+        ffStrbufSubstrAfterFirstC(result, ' ');
+        ffStrbufSubstrBeforeFirstC(result, ' ');
+        return NULL;
+    }
+
+    return "Failed to run command `labwc --version`";
+}
+
+#ifdef __linux__
+static const char* getWslg(FFstrbuf* result)
+{
+    if (!ffAppendFileBuffer("/mnt/wslg/versions.txt", result))
+        return "Failed to read /mnt/wslg/versions.txt";
+
+    if (!ffStrbufStartsWithS(result, "WSLg "))
+        return "Failed to find WSLg version";
+
+    ffStrbufSubstrBeforeFirstC(result, '\n');
+    ffStrbufSubstrBeforeFirstC(result, '+');
+    ffStrbufSubstrAfterFirstC(result, ':');
+    ffStrbufTrimLeft(result, ' ');
+    return NULL;
+}
+#endif
+
+#endif // !__ANDROID__
+
 static bool extractI3Version(const char* line, FF_MAYBE_UNUSED uint32_t len, void *userdata)
 {
     int count = 0;
@@ -161,31 +214,6 @@ static const char* getI3(FFstrbuf* result)
     return "Failed to run command `i3 --version`";
 }
 
-static const char* getWslg(FFstrbuf* result)
-{
-    if (!ffAppendFileBuffer("/mnt/wslg/versions.txt", result))
-        return "Failed to read /mnt/wslg/versions.txt";
-
-    if (!ffStrbufStartsWithS(result, "WSLg "))
-        return "Failed to find WSLg version";
-
-    ffStrbufSubstrBeforeFirstC(result, '\n');
-    ffStrbufSubstrBeforeFirstC(result, '+');
-    ffStrbufSubstrAfterFirstC(result, ':');
-    ffStrbufTrimLeft(result, ' ');
-    return NULL;
-}
-
-static bool extractCommonWmVersion(const char* line, FF_MAYBE_UNUSED uint32_t len, void *userdata)
-{
-    int count = 0;
-    sscanf(line, "%*d.%*d.%*d%n", &count);
-    if (count == 0) return true;
-
-    ffStrbufSetNS((FFstrbuf*) userdata, len, line);
-    return false;
-}
-
 static const char* getCtwm(FFstrbuf* result)
 {
     FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
@@ -255,45 +283,31 @@ static const char* getOpenbox(FFstrbuf* result)
     return "Failed to run command `openbox --version`";
 }
 
-static const char* getLabwc(FFstrbuf* result)
-{
-    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
-    const char* error = ffFindExecutableInPath("labwc", &path);
-    if (error) return "Failed to find labwc executable path";
-
-    ffBinaryExtractStrings(path.chars, extractCommonWmVersion, result, (uint32_t) strlen("0.0.0"));
-    if (result->length > 0) return NULL;
-
-    if (ffProcessAppendStdOut(result, (char* const[]){
-        path.chars,
-        "--version",
-        NULL
-    }) == NULL)
-    { // labwc 0.9.0 (+xwayland +nls +rsvg +libsfdo)
-        ffStrbufSubstrAfterFirstC(result, ' ');
-        ffStrbufSubstrBeforeFirstC(result, ' ');
-        return NULL;
-    }
-
-    return "Failed to run command `labwc --version`";
-}
-
 const char* ffDetectWMVersion(const FFstrbuf* wmName, FFstrbuf* result, FF_MAYBE_UNUSED FFWMOptions* options)
 {
     if (!wmName)
         return "No WM detected";
 
+    #if !__ANDROID__
+    // Wayland compositors
     if (ffStrbufIgnCaseEqualS(wmName, "Hyprland"))
         return getHyprland(result);
 
     if (ffStrbufEqualS(wmName, "sway"))
         return getSway(result);
 
-    if (ffStrbufEqualS(wmName, "i3"))
-        return getI3(result);
+    if (ffStrbufEqualS(wmName, "labwc"))
+        return getLabwc(result);
 
+    #if __linux__
     if (ffStrbufEqualS(wmName, "WSLg"))
         return getWslg(result);
+    #endif
+    #endif
+
+    // X11 WMs
+    if (ffStrbufEqualS(wmName, "i3"))
+        return getI3(result);
 
     if (ffStrbufEqualS(wmName, "ctwm"))
         return getCtwm(result);
@@ -304,8 +318,5 @@ const char* ffDetectWMVersion(const FFstrbuf* wmName, FFstrbuf* result, FF_MAYBE
     if (ffStrbufEqualS(wmName, "Openbox"))
         return getOpenbox(result);
 
-    if (ffStrbufEqualS(wmName, "labwc"))
-        return getLabwc(result);
-
     return "Unsupported WM";
 }