ShuriZma
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

PlatformMisc: Load libdbus at runtime 

The static library can't link to the ARM binary when cross-compiling.
This commit is contained in:
Stenzek 2024-12-30 01:54:31 +10:00
parent a08bd43000
commit 401582bb2b
No known key found for this signature in database
2 changed files with 81 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/util/CMakeLists.txt
View File

@ -264,7 +264,6 @@ elseif(NOT ANDROID)
find_package(PkgConfig REQUIRED) find_package(PkgConfig REQUIRED)
pkg_check_modules(DBUS REQUIRED dbus-1) pkg_check_modules(DBUS REQUIRED dbus-1)
target_include_directories(util PRIVATE ${DBUS_INCLUDE_DIRS}) target_include_directories(util PRIVATE ${DBUS_INCLUDE_DIRS})
target_link_libraries(util PRIVATE ${DBUS_LINK_LIBRARIES})
if(LINUX) if(LINUX)
target_link_libraries(util PRIVATE UDEV::UDEV) target_link_libraries(util PRIVATE UDEV::UDEV)

100
src/util/platform_misc_unix.cpp
View File

@ -4,6 +4,7 @@
#include "input_manager.h" #include "input_manager.h"
#include "platform_misc.h" #include "platform_misc.h"
#include "common/dynamic_library.h"
#include "common/error.h" #include "common/error.h"
#include "common/log.h" #include "common/log.h"
#include "common/path.h" #include "common/path.h"
@ -12,6 +13,7 @@
#include <cinttypes> #include <cinttypes>
#include <dbus/dbus.h> #include <dbus/dbus.h>
#include <mutex>
#include <signal.h> #include <signal.h>
#include <spawn.h> #include <spawn.h>
#include <unistd.h> #include <unistd.h>
@ -32,75 +34,135 @@ bool PlatformMisc::InitializeSocketSupport(Error* error)
static bool SetScreensaverInhibitDBus(const bool inhibit_requested, const char* program_name, const char* reason) static bool SetScreensaverInhibitDBus(const bool inhibit_requested, const char* program_name, const char* reason)
{ {
#define DBUS_FUNCS(X) \
X(dbus_error_is_set) \
X(dbus_error_free) \
X(dbus_message_unref) \
X(dbus_error_init) \
X(dbus_bus_get) \
X(dbus_connection_set_exit_on_disconnect) \
X(dbus_message_new_method_call) \
X(dbus_message_iter_init_append) \
X(dbus_message_iter_append_basic) \
X(dbus_connection_send_with_reply_and_block) \
X(dbus_message_get_args)
static std::mutex s_screensaver_inhibit_dbus_mutex;
static DynamicLibrary s_dbus_library;
static bool s_dbus_library_loaded;
static dbus_uint32_t s_cookie; static dbus_uint32_t s_cookie;
static DBusConnection* s_comparison_connection;
#define DEFINE_FUNC(F) static decltype(&::F) x##F;
DBUS_FUNCS(DEFINE_FUNC)
#undef DEFINE_FUNC
const char* bus_method = (inhibit_requested) ? "Inhibit" : "UnInhibit"; const char* bus_method = (inhibit_requested) ? "Inhibit" : "UnInhibit";
DBusError error; DBusError error;
DBusConnection* connection = nullptr; DBusConnection* connection = nullptr;
static DBusConnection* s_comparison_connection;
DBusMessage* message = nullptr; DBusMessage* message = nullptr;
DBusMessage* response = nullptr; DBusMessage* response = nullptr;
DBusMessageIter message_itr; DBusMessageIter message_itr;
std::unique_lock lock(s_screensaver_inhibit_dbus_mutex);
if (!s_dbus_library_loaded)
{
Error lerror;
s_dbus_library_loaded = true;
if (!s_dbus_library.Open(DynamicLibrary::GetVersionedFilename("dbus", 1).c_str(), &lerror))
{
ERROR_LOG("Failed to open libdbus: {}", lerror.GetDescription());
return false;
}
#define LOAD_FUNC(F) \
if (!s_dbus_library.GetSymbol(#F, &x##F)) \
{ \
ERROR_LOG("Failed to find function {}", #F); \
s_dbus_library.Close(); \
return false; \
}
DBUS_FUNCS(LOAD_FUNC)
#undef LOAD_FUNC
}
if (!s_dbus_library.IsOpen())
return false;
ScopedGuard cleanup = [&]() { ScopedGuard cleanup = [&]() {
if (dbus_error_is_set(&error)) if (xdbus_error_is_set(&error))
{ {
ERROR_LOG("SetScreensaverInhibitDBus error: {}", error.message); ERROR_LOG("SetScreensaverInhibitDBus error: {}", error.message);
dbus_error_free(&error); xdbus_error_free(&error);
} }
if (message) if (message)
dbus_message_unref(message); xdbus_message_unref(message);
if (response) if (response)
dbus_message_unref(response); xdbus_message_unref(response);
}; };
dbus_error_init(&error); xdbus_error_init(&error);
// Calling dbus_bus_get() after the first time returns a pointer to the existing connection. // Calling dbus_bus_get() after the first time returns a pointer to the existing connection.
connection = dbus_bus_get(DBUS_BUS_SESSION, &error); connection = xdbus_bus_get(DBUS_BUS_SESSION, &error);
if (!connection || (dbus_error_is_set(&error))) if (!connection || (xdbus_error_is_set(&error)))
return false; return false;
if (s_comparison_connection != connection) if (s_comparison_connection != connection)
{ {
dbus_connection_set_exit_on_disconnect(connection, false); xdbus_connection_set_exit_on_disconnect(connection, false);
s_cookie = 0; s_cookie = 0;
s_comparison_connection = connection; s_comparison_connection = connection;
} }
message = dbus_message_new_method_call("org.freedesktop.ScreenSaver", "/org/freedesktop/ScreenSaver",
"org.freedesktop.ScreenSaver", bus_method); message = xdbus_message_new_method_call("org.freedesktop.ScreenSaver", "/org/freedesktop/ScreenSaver",
"org.freedesktop.ScreenSaver", bus_method);
if (!message) if (!message)
return false; return false;
// Initialize an append iterator for the message, gets freed with the message. // Initialize an append iterator for the message, gets freed with the message.
dbus_message_iter_init_append(message, &message_itr); xdbus_message_iter_init_append(message, &message_itr);
if (inhibit_requested) if (inhibit_requested)
{ {
// Guard against repeat inhibitions which would add extra inhibitors each generating a different cookie. // Guard against repeat inhibitions which would add extra inhibitors each generating a different cookie.
if (s_cookie) if (s_cookie)
return false; return false;
// Append process/window name. // Append process/window name.
if (!dbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &program_name)) if (!xdbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &program_name))
return false; return false;
// Append reason for inhibiting the screensaver. // Append reason for inhibiting the screensaver.
if (!dbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &reason)) if (!xdbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &reason))
return false; return false;
} }
else else
{ {
// Only Append the cookie. // Only Append the cookie.
if (!dbus_message_iter_append_basic(&message_itr, DBUS_TYPE_UINT32, &s_cookie)) if (!xdbus_message_iter_append_basic(&message_itr, DBUS_TYPE_UINT32, &s_cookie))
return false; return false;
} }
// Send message and get response. // Send message and get response.
response = dbus_connection_send_with_reply_and_block(connection, message, DBUS_TIMEOUT_USE_DEFAULT, &error); response = xdbus_connection_send_with_reply_and_block(connection, message, DBUS_TIMEOUT_USE_DEFAULT, &error);
if (!response || dbus_error_is_set(&error)) if (!response || xdbus_error_is_set(&error))
return false; return false;
s_cookie = 0; s_cookie = 0;
if (inhibit_requested) if (inhibit_requested)
{ {
// Get the cookie from the response message. // Get the cookie from the response message.
if (!dbus_message_get_args(response, &error, DBUS_TYPE_UINT32, &s_cookie, DBUS_TYPE_INVALID) || if (!xdbus_message_get_args(response, &error, DBUS_TYPE_UINT32, &s_cookie, DBUS_TYPE_INVALID) ||
dbus_error_is_set(&error)) xdbus_error_is_set(&error))
{
return false; return false;
}
} }
return true; return true;
#undef DBUS_FUNCS
} }
static bool SetScreensaverInhibit(bool inhibit) static bool SetScreensaverInhibit(bool inhibit)