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)
pkg_check_modules(DBUS REQUIRED dbus-1)
target_include_directories(util PRIVATE ${DBUS_INCLUDE_DIRS})
target_link_libraries(util PRIVATE ${DBUS_LINK_LIBRARIES})
if(LINUX)
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 "platform_misc.h"
#include "common/dynamic_library.h"
#include "common/error.h"
#include "common/log.h"
#include "common/path.h"
@ -12,6 +13,7 @@
#include <cinttypes>
#include <dbus/dbus.h>
#include <mutex>
#include <signal.h>
#include <spawn.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)
{
#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 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";
DBusError error;
DBusConnection* connection = nullptr;
static DBusConnection* s_comparison_connection;
DBusMessage* message = nullptr;
DBusMessage* response = nullptr;
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 = [&]() {
if (dbus_error_is_set(&error))
if (xdbus_error_is_set(&error))
{
ERROR_LOG("SetScreensaverInhibitDBus error: {}", error.message);
dbus_error_free(&error);
xdbus_error_free(&error);
}
if (message)
dbus_message_unref(message);
xdbus_message_unref(message);
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.
connection = dbus_bus_get(DBUS_BUS_SESSION, &error);
if (!connection || (dbus_error_is_set(&error)))
connection = xdbus_bus_get(DBUS_BUS_SESSION, &error);
if (!connection || (xdbus_error_is_set(&error)))
return false;
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_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)
return false;
// 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)
{
// Guard against repeat inhibitions which would add extra inhibitors each generating a different cookie.
if (s_cookie)
return false;
// 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;
// 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;
}
else
{
// 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;
}
// Send message and get response.
response = dbus_connection_send_with_reply_and_block(connection, message, DBUS_TIMEOUT_USE_DEFAULT, &error);
if (!response || dbus_error_is_set(&error))
response = xdbus_connection_send_with_reply_and_block(connection, message, DBUS_TIMEOUT_USE_DEFAULT, &error);
if (!response || xdbus_error_is_set(&error))
return false;
s_cookie = 0;
if (inhibit_requested)
{
// Get the cookie from the response message.
if (!dbus_message_get_args(response, &error, DBUS_TYPE_UINT32, &s_cookie, DBUS_TYPE_INVALID) ||
dbus_error_is_set(&error))
if (!xdbus_message_get_args(response, &error, DBUS_TYPE_UINT32, &s_cookie, DBUS_TYPE_INVALID) ||
xdbus_error_is_set(&error))
{
return false;
}
}
return true;
#undef DBUS_FUNCS
}
static bool SetScreensaverInhibit(bool inhibit)